single repo
This commit is contained in:
Adolfo Reyna
BIN
Pico_ePaper_Code/python/Pico 2.uf2
Normal file
BIN
Pico_ePaper_Code/python/Pico 2.uf2
Normal file
Binary file not shown.
609
Pico_ePaper_Code/python/Pico-ePaper-2.7.py
Normal file
609
Pico_ePaper_Code/python/Pico-ePaper-2.7.py
Normal file
@@ -0,0 +1,609 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.7.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-06-03
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 176
|
||||
EPD_HEIGHT = 264
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
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
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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
|
||||
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
|
||||
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,
|
||||
]
|
||||
# R22Hr
|
||||
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,
|
||||
]
|
||||
# R23Hw
|
||||
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,
|
||||
]
|
||||
# R24Hb
|
||||
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,
|
||||
]
|
||||
|
||||
class EPD_2in7:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.lut_vcom_dc = EPD_2in7_lut_vcom_dc
|
||||
self.lut_ww = EPD_2in7_lut_ww
|
||||
self.lut_bw = EPD_2in7_lut_bw
|
||||
self.lut_bb = EPD_2in7_lut_bb
|
||||
self.lut_wb = EPD_2in7_lut_wb
|
||||
|
||||
self.gray_lut_vcom = EPD_2in7_gray_lut_vcom
|
||||
self.gray_lut_ww = EPD_2in7_gray_lut_ww
|
||||
self.gray_lut_bw = EPD_2in7_gray_lut_bw
|
||||
self.gray_lut_wb = EPD_2in7_gray_lut_wb
|
||||
self.gray_lut_bb = EPD_2in7_gray_lut_bb
|
||||
|
||||
self.black = 0x00
|
||||
self.white = 0xff
|
||||
self.darkgray = 0xaa
|
||||
self.grayish = 0x55
|
||||
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_1Gray_Landscape = bytearray(self.height * self.width // 8)
|
||||
self.buffer_1Gray_Portrait = bytearray(self.height * self.width // 8)
|
||||
self.buffer_4Gray = bytearray(self.height * self.width // 4)
|
||||
|
||||
self.image1Gray_Landscape = framebuf.FrameBuffer(self.buffer_1Gray_Landscape, self.height, self.width, framebuf.MONO_VLSB)
|
||||
self.image1Gray_Portrait = framebuf.FrameBuffer(self.buffer_1Gray_Portrait, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.image4Gray = framebuf.FrameBuffer(self.buffer_4Gray, self.width, self.height, framebuf.GS2_HMSB)
|
||||
|
||||
self.EPD_2IN7_Init_4Gray()
|
||||
self.EPD_2IN7_Clear()
|
||||
utime.sleep_ms(500)
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 0): # 0: idle, 1: busy
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(200)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def SetLut(self):
|
||||
self.send_command(0x20)
|
||||
for count in range(0, 44):
|
||||
self.send_data(self.lut_vcom_dc[count])
|
||||
|
||||
self.send_command(0x21)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.lut_ww[count])
|
||||
|
||||
self.send_command(0x22)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.lut_bw[count])
|
||||
|
||||
self.send_command(0x23)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.lut_bb[count])
|
||||
|
||||
self.send_command(0x24)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.lut_wb[count])
|
||||
|
||||
def gray_SetLut(self):
|
||||
self.send_command(0x20)
|
||||
for count in range(0, 44):
|
||||
self.send_data(self.gray_lut_vcom[count])
|
||||
|
||||
self.send_command(0x21)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.gray_lut_ww[count])
|
||||
|
||||
self.send_command(0x22)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.gray_lut_bw[count])
|
||||
|
||||
self.send_command(0x23)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.gray_lut_wb[count])
|
||||
|
||||
self.send_command(0x24)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.gray_lut_bb[count])
|
||||
|
||||
self.send_command(0x25)
|
||||
for count in range(0, 42):
|
||||
self.send_data(self.gray_lut_ww[count])
|
||||
|
||||
|
||||
def EPD_2IN7_Init(self):
|
||||
|
||||
self.reset();
|
||||
|
||||
self.send_command(0x01) # POWER_SETTING
|
||||
self.send_data(0x03) # VDS_EN, VDG_EN
|
||||
self.send_data(0x00) # VCOM_HV, VGHL_LV[1], VGHL_LV[0]
|
||||
self.send_data(0x2b) # VDH
|
||||
self.send_data(0x2b) # VDL
|
||||
self.send_data(0x09) # VDHR
|
||||
|
||||
self.send_command(0x06) # BOOSTER_SOFT_START
|
||||
self.send_data(0x07)
|
||||
self.send_data(0x07)
|
||||
self.send_data(0x17)
|
||||
|
||||
# Power optimization
|
||||
self.send_command(0xF8)
|
||||
self.send_data(0x60)
|
||||
self.send_data(0xA5)
|
||||
|
||||
# Power optimization
|
||||
self.send_command(0xF8)
|
||||
self.send_data(0x89)
|
||||
self.send_data(0xA5)
|
||||
|
||||
# Power optimization
|
||||
self.send_command(0xF8)
|
||||
self.send_data(0x90)
|
||||
self.send_data(0x00)
|
||||
|
||||
# Power optimization
|
||||
self.send_command(0xF8)
|
||||
self.send_data(0x93)
|
||||
self.send_data(0x2A)
|
||||
|
||||
# Power optimization
|
||||
self.send_command(0xF8)
|
||||
self.send_data(0xA0)
|
||||
self.send_data(0xA5)
|
||||
|
||||
# Power optimization
|
||||
self.send_command(0xF8)
|
||||
self.send_data(0xA1)
|
||||
self.send_data(0x00)
|
||||
|
||||
# Power optimization
|
||||
self.send_command(0xF8)
|
||||
self.send_data(0x73)
|
||||
self.send_data(0x41)
|
||||
|
||||
self.send_command(0x16) # PARTIAL_DISPLAY_REFRESH
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x04) # POWER_ON
|
||||
self.ReadBusy();
|
||||
|
||||
self.send_command(0x00) # PANEL_SETTING
|
||||
self.send_data(0xAF) # KW-BF KWR-AF BWROTP 0f
|
||||
self.send_command(0x30) # PLL_CONTROL
|
||||
self.send_data(0x3A) # 3A 100HZ 29 150Hz 39 200HZ 31 171HZ
|
||||
self.send_command(0x82) # VCM_DC_SETTING_REGISTER
|
||||
self.send_data(0x12)
|
||||
|
||||
self.SetLut()
|
||||
|
||||
def EPD_2IN7_Init_4Gray(self):
|
||||
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x01) # POWER SETTING
|
||||
self.send_data (0x03)
|
||||
self.send_data (0x00)
|
||||
self.send_data (0x2b)
|
||||
self.send_data (0x2b)
|
||||
|
||||
|
||||
self.send_command(0x06) # booster soft start
|
||||
self.send_data (0x07) # A
|
||||
self.send_data (0x07) # B
|
||||
self.send_data (0x17) # C
|
||||
|
||||
self.send_command(0xF8) # boost??
|
||||
self.send_data (0x60)
|
||||
self.send_data (0xA5)
|
||||
|
||||
self.send_command(0xF8) # boost??
|
||||
self.send_data (0x89)
|
||||
self.send_data (0xA5)
|
||||
|
||||
self.send_command(0xF8) # boost??
|
||||
self.send_data (0x90)
|
||||
self.send_data (0x00)
|
||||
|
||||
self.send_command(0xF8) # boost??
|
||||
self.send_data (0x93)
|
||||
self.send_data (0x2A)
|
||||
|
||||
self.send_command(0xF8) # boost??
|
||||
self.send_data (0xa0)
|
||||
self.send_data (0xa5)
|
||||
|
||||
self.send_command(0xF8) # boost??
|
||||
self.send_data (0xa1)
|
||||
self.send_data (0x00)
|
||||
|
||||
self.send_command(0xF8) # boost??
|
||||
self.send_data (0x73)
|
||||
self.send_data (0x41)
|
||||
|
||||
self.send_command(0x16)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x04)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x00) # panel setting
|
||||
self.send_data(0xbf) # KW-BF KWR-AF BWROTP 0f
|
||||
|
||||
self.send_command(0x30) # PLL setting
|
||||
self.send_data (0x90) # 100hz
|
||||
|
||||
self.send_command(0x61) # resolution setting
|
||||
self.send_data (0x00) # 176
|
||||
self.send_data (0xb0)
|
||||
self.send_data (0x01) # 264
|
||||
self.send_data (0x08)
|
||||
|
||||
self.send_command(0x82) # vcom_DC setting
|
||||
self.send_data (0x12)
|
||||
|
||||
self.send_command(0X50) # VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x97)
|
||||
|
||||
def EPD_2IN7_Clear(self):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(0xff)
|
||||
|
||||
self.send_command(0x13)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(0xff)
|
||||
|
||||
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_2IN7_Display_Portrait(self,Image):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(0xff)
|
||||
|
||||
self.send_command(0x13)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(Image[i + j * wide])
|
||||
|
||||
|
||||
def EPD_2IN7_Display_Landscape(self,Image):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(0xff)
|
||||
|
||||
self.send_command(0x13)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(Image[(21-i) * high + j])
|
||||
|
||||
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_2IN7_4Gray_Display(self,Image):
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, 5808):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = Image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01;
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00;
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
|
||||
self.send_data(temp3)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, 5808):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = Image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01;
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00;
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
|
||||
self.send_data(temp3)
|
||||
|
||||
self.gray_SetLut()
|
||||
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(500)
|
||||
|
||||
self.ReadBusy()
|
||||
|
||||
|
||||
def Sleep(self):
|
||||
self.send_command(0X50)
|
||||
self.send_data(0xf7)
|
||||
self.send_command(0X02) # power off
|
||||
self.send_command(0X07) # deep sleep
|
||||
self.send_data(0xA5)
|
||||
|
||||
if __name__=='__main__':
|
||||
|
||||
epd = EPD_2in7()
|
||||
|
||||
epd.image1Gray_Landscape.fill(0xff)
|
||||
epd.image1Gray_Portrait.fill(0xff)
|
||||
epd.image4Gray.fill(0xff)
|
||||
|
||||
epd.image4Gray.text("Waveshare", 5, 5, epd.black)
|
||||
epd.image4Gray.text("Pico_ePaper-2.7", 5, 20, epd.black)
|
||||
epd.image4Gray.text("Raspberry Pico", 5, 35, epd.black)
|
||||
epd.EPD_2IN7_4Gray_Display(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.vline(10, 60, 60, epd.black)
|
||||
epd.image4Gray.vline(90, 60, 60, epd.black)
|
||||
epd.image4Gray.hline(10, 60, 80, epd.black)
|
||||
epd.image4Gray.hline(10, 120, 80, epd.black)
|
||||
epd.image4Gray.line(10, 60, 90, 120, epd.black)
|
||||
epd.image4Gray.line(90, 60, 10, 120, epd.black)
|
||||
epd.EPD_2IN7_4Gray_Display(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.rect(10, 136, 50, 80, epd.black)
|
||||
epd.image4Gray.fill_rect(70, 136, 50, 80, epd.black)
|
||||
epd.EPD_2IN7_4Gray_Display(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.fill_rect(0, 232, 88, 16, epd.black)
|
||||
epd.image4Gray.text('GRAY1',24, 236, epd.white)
|
||||
epd.image4Gray.text('GRAY2',24, 252, epd.grayish)
|
||||
epd.image4Gray.text('GRAY3',112, 236, epd.darkgray)
|
||||
epd.image4Gray.text('GRAY4',112, 252, epd.black)
|
||||
epd.EPD_2IN7_4Gray_Display(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
|
||||
|
||||
epd.EPD_2IN7_Init()
|
||||
epd.EPD_2IN7_Clear()
|
||||
epd.image1Gray_Landscape.text("Waveshare", 5, 5, epd.black)
|
||||
epd.image1Gray_Landscape.text("Pico_ePaper-2.7", 5, 20, epd.black)
|
||||
epd.image1Gray_Landscape.text("Raspberry Pico", 5, 35, epd.black)
|
||||
epd.EPD_2IN7_Display_Landscape(epd.buffer_1Gray_Landscape)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.EPD_2IN7_Clear()
|
||||
print("Sleep")
|
||||
epd.Sleep()
|
||||
|
||||
|
||||
|
||||
|
||||
522
Pico_ePaper_Code/python/Pico-ePaper-2.7_V2.py
Normal file
522
Pico_ePaper_Code/python/Pico-ePaper-2.7_V2.py
Normal file
@@ -0,0 +1,522 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.7_V2.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2022-03-15
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 176
|
||||
EPD_HEIGHT = 264
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
LUT_DATA_4Gray = [
|
||||
0x40,0x48,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0x8,0x48,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0x2,0x48,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0x20,0x48,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0xA,0x19,0x0,0x3,0x8,0x0,0x0,
|
||||
0x14,0x1,0x0,0x14,0x1,0x0,0x3,
|
||||
0xA,0x3,0x0,0x8,0x19,0x0,0x0,
|
||||
0x1,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,
|
||||
0x22,0x22,0x22,0x22,0x22,0x22,0x0,0x0,0x0,
|
||||
0x22,0x17,0x41,0x0,0x32,0x1C,
|
||||
]
|
||||
|
||||
|
||||
class EPD_2in7_V2:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.black = 0x00
|
||||
self.white = 0xff
|
||||
self.darkgray = 0xaa
|
||||
self.grayish = 0x55
|
||||
|
||||
self.LUT_DATA_4Gray = LUT_DATA_4Gray
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_1Gray_Landscape = bytearray(self.height * self.width // 8)
|
||||
self.buffer_1Gray_Portrait = bytearray(self.height * self.width // 8)
|
||||
self.buffer_4Gray = bytearray(self.height * self.width // 4)
|
||||
|
||||
self.image1Gray_Landscape = framebuf.FrameBuffer(self.buffer_1Gray_Landscape, self.height, self.width, framebuf.MONO_VLSB)
|
||||
self.image1Gray_Portrait = framebuf.FrameBuffer(self.buffer_1Gray_Portrait, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.image4Gray = framebuf.FrameBuffer(self.buffer_4Gray, self.width, self.height, framebuf.GS2_HMSB)
|
||||
|
||||
self.init()
|
||||
self.clear()
|
||||
utime.sleep_ms(500)
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 1): # 1: idle, 0: busy
|
||||
self.delay_ms(2)
|
||||
self.delay_ms(200)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xF7)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Fast(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Partial(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xFF)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_4GRAY(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
|
||||
def Lut(self):
|
||||
self.send_command(0x32)
|
||||
for i in range(159):
|
||||
self.send_data(self.LUT_DATA_4Gray[i])
|
||||
|
||||
def init(self):
|
||||
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x45) #set Ram-Y address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x07) #0x0107-->(263+1)=264
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x4F) # set RAM y address count to 0;
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x03)
|
||||
return 0
|
||||
|
||||
def init_Fast(self):
|
||||
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x18) #Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0xB1)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x1A) # Write to temperature register
|
||||
self.send_data(0x64)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x45) #set Ram-Y address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x07) #0x0107-->(263+1)=264
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x4F) # set RAM y address count to 0;
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0x91)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
return 0
|
||||
|
||||
def init_4Gray(self):
|
||||
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x12) # soft reset
|
||||
self.ReadBusy();
|
||||
|
||||
self.send_command(0x74) #set analog block control
|
||||
self.send_data(0x54)
|
||||
self.send_command(0x7E) #set digital block control
|
||||
self.send_data(0x3B)
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data(0x07)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x44) #set Ram-X address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x15) #0x15-->(21+1)*8=176
|
||||
|
||||
self.send_command(0x45) #set Ram-Y address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x07) #0x0107-->(263+1)=264
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x3C) #BorderWavefrom
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x2C) #VCOM Voltage
|
||||
self.send_data(self.LUT_DATA_4Gray[158]) #0x1C
|
||||
|
||||
self.send_command(0x3F) #EOPQ
|
||||
self.send_data(self.LUT_DATA_4Gray[153])
|
||||
|
||||
self.send_command(0x03) #VGH
|
||||
self.send_data(self.LUT_DATA_4Gray[154])
|
||||
|
||||
self.send_command(0x04) #
|
||||
self.send_data(self.LUT_DATA_4Gray[155]) #VSH1
|
||||
self.send_data(self.LUT_DATA_4Gray[156]) #VSH2
|
||||
self.send_data(self.LUT_DATA_4Gray[157]) #VSL
|
||||
|
||||
self.Lut() #LUT
|
||||
|
||||
self.send_command(0x4E) # set RAM x address count to 0;
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F) # set RAM y address count to 0X199;
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
return 0
|
||||
|
||||
def clear(self):
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
self.send_command(0x24)
|
||||
self.send_data1([0xff] * Width * Height)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display(self, image):
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Landscape(self, image):
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
self.send_command(0x24)
|
||||
for j in range(Height):
|
||||
for i in range(Width):
|
||||
self.send_data(image[(21-i) * Height + j])
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Fast(self, image):
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplay_Fast()
|
||||
|
||||
def display_Base(self, image):
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
self.send_command(0x24) #Write Black and White image to RAM
|
||||
self.send_data1(image)
|
||||
|
||||
self.send_command(0x26) #Write Black and White image to RAM
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Base_color(self, color):
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
self.send_command(0x24) #Write Black and White image to RAM
|
||||
self.send_data1([color] * Width * Height)
|
||||
|
||||
self.send_command(0x26) #Write Black and White image to RAM
|
||||
self.send_data1([color] * Width * Height)
|
||||
|
||||
# self.TurnOnDisplay()
|
||||
|
||||
def display_Partial(self, image):
|
||||
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x3C) #BorderWavefrom
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x24) #Write Black and White image to RAM
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay_Partial()
|
||||
|
||||
def display_4Gray(self, image):
|
||||
self.send_command(0x24)
|
||||
for i in range(0, 5808): #5808*4 46464
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x00 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x01 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x00;
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x01;
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
temp1 >>= 2
|
||||
self.send_data(temp3)
|
||||
|
||||
self.send_command(0x26)
|
||||
for i in range(0, 5808): #5808*4 46464
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x00 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x01 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x00;
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x01;
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
if(j!=1 or k!=1):
|
||||
temp3 <<= 1
|
||||
temp1 >>= 2
|
||||
self.send_data(temp3)
|
||||
|
||||
self.TurnOnDisplay_4GRAY()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0X10)
|
||||
self.send_data(0x01)
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
|
||||
epd = EPD_2in7_V2()
|
||||
|
||||
epd.image1Gray_Landscape.fill(0xff)
|
||||
epd.image1Gray_Portrait.fill(0xff)
|
||||
epd.image4Gray.fill(0xff)
|
||||
# You are advised to fill the cache area inside the ink screen first. Otherwise, the office brush may be abnormal
|
||||
epd.display_Base_color(0xff)
|
||||
|
||||
epd.image1Gray_Portrait.text("Waveshare", 5, 5, epd.black)
|
||||
epd.image1Gray_Portrait.text("Pico_ePaper-2.7", 5, 20, epd.black)
|
||||
epd.image1Gray_Portrait.text("Raspberry Pico", 5, 35, epd.black)
|
||||
epd.display_Fast(epd.buffer_1Gray_Portrait)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image1Gray_Portrait.vline(10, 60, 60, epd.black)
|
||||
epd.image1Gray_Portrait.vline(90, 60, 60, epd.black)
|
||||
epd.image1Gray_Portrait.hline(10, 60, 80, epd.black)
|
||||
epd.image1Gray_Portrait.hline(10, 120, 80, epd.black)
|
||||
epd.image1Gray_Portrait.line(10, 60, 90, 120, epd.black)
|
||||
epd.image1Gray_Portrait.line(90, 60, 10, 120, epd.black)
|
||||
epd.display_Fast(epd.buffer_1Gray_Portrait)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image1Gray_Portrait.rect(10, 136, 50, 80, epd.black)
|
||||
epd.image1Gray_Portrait.fill_rect(70, 136, 50, 80, epd.black)
|
||||
epd.display_Fast(epd.buffer_1Gray_Portrait)
|
||||
epd.delay_ms(500)
|
||||
|
||||
for i in range(0, 10):
|
||||
epd.image1Gray_Portrait.fill_rect(60, 240, 40, 10, 0xff)
|
||||
epd.image1Gray_Portrait.text(str(i), 80, 241, 0x00)
|
||||
epd.display_Partial(epd.buffer_1Gray_Portrait)
|
||||
|
||||
epd.init_4Gray()
|
||||
epd.image4Gray.fill_rect(0, 0, 175, 68, epd.black)
|
||||
epd.image4Gray.text('GRAY1',10, 30, epd.white)
|
||||
epd.image4Gray.fill_rect(0, 68, 175, 68, epd.darkgray)
|
||||
epd.image4Gray.text('GRAY2',10, 98, epd.grayish)
|
||||
epd.image4Gray.fill_rect(0, 136, 175, 68, epd.grayish)
|
||||
epd.image4Gray.text('GRAY3',10, 166, epd.darkgray)
|
||||
epd.image4Gray.fill_rect(0, 204, 175, 68, epd.white)
|
||||
epd.image4Gray.text('GRAY4',10, 234, epd.black)
|
||||
epd.display_4Gray(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.init()
|
||||
epd.clear()
|
||||
epd.image1Gray_Landscape.text("Waveshare", 5, 5, epd.black)
|
||||
epd.image1Gray_Landscape.text("Pico_ePaper-2.7", 5, 20, epd.black)
|
||||
epd.image1Gray_Landscape.text("Raspberry Pico", 5, 35, epd.black)
|
||||
epd.display_Landscape(epd.buffer_1Gray_Landscape)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.clear()
|
||||
print("Sleep")
|
||||
epd.sleep()
|
||||
|
||||
|
||||
|
||||
|
||||
621
Pico_ePaper_Code/python/Pico-ePaper-3.7.py
Normal file
621
Pico_ePaper_Code/python/Pico-ePaper-3.7.py
Normal file
@@ -0,0 +1,621 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-3.7.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-06-01
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 280
|
||||
EPD_HEIGHT = 480
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
EPD_3IN7_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
|
||||
]
|
||||
|
||||
EPD_3IN7_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
|
||||
]
|
||||
|
||||
EPD_3IN7_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
|
||||
]
|
||||
|
||||
EPD_3IN7_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
|
||||
]
|
||||
|
||||
class EPD_3in7:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.lut_4Gray_GC = EPD_3IN7_lut_4Gray_GC
|
||||
self.lut_1Gray_GC = EPD_3IN7_lut_1Gray_GC
|
||||
self.lut_1Gray_DU = EPD_3IN7_lut_1Gray_DU
|
||||
self.lut_1Gray_A2 = EPD_3IN7_lut_1Gray_A2
|
||||
|
||||
self.black = 0x00
|
||||
self.white = 0xff
|
||||
self.darkgray = 0xaa
|
||||
self.grayish = 0x55
|
||||
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_1Gray = bytearray(self.height * self.width // 8)
|
||||
self.buffer_4Gray = bytearray(self.height * self.width // 4)
|
||||
self.image1Gray = framebuf.FrameBuffer(self.buffer_1Gray, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.image4Gray = framebuf.FrameBuffer(self.buffer_4Gray, self.width, self.height, framebuf.GS2_HMSB)
|
||||
|
||||
self.EPD_3IN7_4Gray_init()
|
||||
self.EPD_3IN7_4Gray_Clear()
|
||||
utime.sleep_ms(500)
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(30)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(3)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(30)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 1): # 0: idle, 1: busy
|
||||
self.delay_ms(10)
|
||||
self.delay_ms(200)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def Load_LUT(self,lut):
|
||||
self.send_command(0x32)
|
||||
for count in range(0, 105):
|
||||
if lut == 0 :
|
||||
self.send_data(self.lut_4Gray_GC[count])
|
||||
elif lut == 1 :
|
||||
self.send_data(self.lut_1Gray_GC[count])
|
||||
elif lut == 2 :
|
||||
self.send_data(self.lut_1Gray_DU[count])
|
||||
elif lut == 3 :
|
||||
self.send_data(self.lut_1Gray_A2[count])
|
||||
else:
|
||||
print("There is no such lut ")
|
||||
|
||||
def EPD_3IN7_4Gray_init(self):
|
||||
|
||||
self.reset() # SWRESET
|
||||
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(300)
|
||||
|
||||
self.send_command(0x46)
|
||||
self.send_data(0xF7)
|
||||
self.ReadBusy()
|
||||
self.send_command(0x47)
|
||||
self.send_data(0xF7)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) # setting gaet number
|
||||
self.send_data(0xDF)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x03) # set gate voltage
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x04) # set source voltage
|
||||
self.send_data(0x41)
|
||||
self.send_data(0xA8)
|
||||
self.send_data(0x32)
|
||||
|
||||
self.send_command(0x11) # set data entry sequence
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x3C) # set border
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x0C) # set booster strength
|
||||
self.send_data(0xAE)
|
||||
self.send_data(0xC7)
|
||||
self.send_data(0xC3)
|
||||
self.send_data(0xC0)
|
||||
self.send_data(0xC0)
|
||||
|
||||
self.send_command(0x18) # set internal sensor on
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x2C) # set vcom value
|
||||
self.send_data(0x44)
|
||||
|
||||
self.send_command(0x37) # set display option, these setting turn on previous function
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x44) # setting X direction start/end position of RAM
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x45) # setting Y direction start/end position of RAM
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0xDF)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x22) # Display Update Control 2
|
||||
self.send_data(0xCF)
|
||||
|
||||
def EPD_3IN7_1Gray_init(self):
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(300)
|
||||
|
||||
self.send_command(0x46)
|
||||
self.send_data(0xF7)
|
||||
self.ReadBusy()
|
||||
self.send_command(0x47)
|
||||
self.send_data(0xF7)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) # setting gaet number
|
||||
self.send_data(0xDF)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x03) # set gate voltage
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x04) # set source voltage
|
||||
self.send_data(0x41)
|
||||
self.send_data(0xA8)
|
||||
self.send_data(0x32)
|
||||
|
||||
self.send_command(0x11) # set data entry sequence
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x3C) # set border
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x0C) # set booster strength
|
||||
self.send_data(0xAE)
|
||||
self.send_data(0xC7)
|
||||
self.send_data(0xC3)
|
||||
self.send_data(0xC0)
|
||||
self.send_data(0xC0)
|
||||
|
||||
self.send_command(0x18) # set internal sensor on
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x2C) # set vcom value
|
||||
self.send_data(0x44)
|
||||
|
||||
self.send_command(0x37) # set display option, these setting turn on previous function
|
||||
self.send_data(0x00) # can switch 1 gray or 4 gray
|
||||
self.send_data(0xFF)
|
||||
self.send_data(0xFF)
|
||||
self.send_data(0xFF)
|
||||
self.send_data(0xFF)
|
||||
self.send_data(0x4F)
|
||||
self.send_data(0xFF)
|
||||
self.send_data(0xFF)
|
||||
self.send_data(0xFF)
|
||||
self.send_data(0xFF)
|
||||
|
||||
self.send_command(0x44) # setting X direction start/end position of RAM
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x45) # setting Y direction start/end position of RAM
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0xDF)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x22) # Display Update Control 2
|
||||
self.send_data(0xCF)
|
||||
|
||||
def EPD_3IN7_4Gray_Clear(self):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x49)
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x24)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(0Xff)
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x26)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(0Xff)
|
||||
|
||||
self.Load_LUT(0)
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xC7)
|
||||
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_3IN7_1Gray_Clear(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x24)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(0Xff)
|
||||
|
||||
|
||||
self.Load_LUT(1)
|
||||
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_3IN7_4Gray_Display(self,Image):
|
||||
|
||||
self.send_command(0x49)
|
||||
self.send_data(0x00)
|
||||
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x24)
|
||||
for i in range(0, 16800):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = Image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01;
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00;
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
|
||||
self.send_data(temp3)
|
||||
# new data
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x26)
|
||||
for i in range(0, 16800):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = Image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01;
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00;
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
|
||||
self.send_data(temp3)
|
||||
|
||||
self.Load_LUT(0)
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xC7)
|
||||
|
||||
self.send_command(0x20)
|
||||
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_3IN7_1Gray_Display(self,Image):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x49)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x24)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(Image[i + j * wide])
|
||||
|
||||
|
||||
self.Load_LUT(1)
|
||||
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_3IN7_1Gray_Display_Part(self,Image):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x44)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data((self.width-1) & 0xff)
|
||||
self.send_data(((self.width-1)>>8) & 0x03)
|
||||
self.send_command(0x45)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data((self.height-1) & 0xff)
|
||||
self.send_data(((self.height-1)>>8) & 0x03)
|
||||
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x24)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(Image[i + j * wide])
|
||||
|
||||
self.Load_LUT(2)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
def Sleep(self):
|
||||
self.send_command(0X10) # deep sleep
|
||||
self.send_data(0x03)
|
||||
|
||||
if __name__=='__main__':
|
||||
|
||||
epd = EPD_3in7()
|
||||
|
||||
epd.image1Gray.fill(0xff)
|
||||
epd.image4Gray.fill(0xff)
|
||||
|
||||
epd.image4Gray.text("Waveshare", 5, 10, epd.black)
|
||||
epd.image4Gray.text("Pico_ePaper-3.7", 5, 40, epd.black)
|
||||
epd.image4Gray.text("Raspberry Pico", 5, 70, epd.black)
|
||||
epd.EPD_3IN7_4Gray_Display(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.vline(10, 90, 60, epd.black)
|
||||
epd.image4Gray.vline(90, 90, 60, epd.black)
|
||||
epd.image4Gray.hline(10, 90, 80, epd.black)
|
||||
epd.image4Gray.hline(10, 150, 80, epd.black)
|
||||
epd.image4Gray.line(10, 90, 90, 150, epd.black)
|
||||
epd.image4Gray.line(90, 90, 10, 150, epd.black)
|
||||
epd.EPD_3IN7_4Gray_Display(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.rect(10, 180, 50, 80, epd.black)
|
||||
epd.image4Gray.fill_rect(70, 180, 50, 80, epd.black)
|
||||
epd.EPD_3IN7_4Gray_Display(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.fill_rect(0, 270, 280, 30, epd.black)
|
||||
epd.image4Gray.text('GRAY1 with black background',5, 281, epd.white)
|
||||
epd.image4Gray.text('GRAY2 with white background',5, 311, epd.grayish)
|
||||
epd.image4Gray.text('GRAY3 with white background',5, 341, epd.darkgray)
|
||||
epd.image4Gray.text('GRAY4 with white background',5, 371, epd.black)
|
||||
epd.EPD_3IN7_4Gray_Display(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
|
||||
epd.EPD_3IN7_1Gray_init()
|
||||
for i in range(0, 10):
|
||||
epd.image1Gray.fill_rect(0, 430, 280, 10, epd.white)
|
||||
epd.image1Gray.text(str(i), 136, 431, epd.black)
|
||||
epd.EPD_3IN7_1Gray_Display_Part(epd.buffer_1Gray)
|
||||
|
||||
|
||||
|
||||
|
||||
epd.Sleep()
|
||||
|
||||
|
||||
312
Pico_ePaper_Code/python/Pico-ePaper-4.2-B.py
Normal file
312
Pico_ePaper_Code/python/Pico-ePaper-4.2-B.py
Normal file
@@ -0,0 +1,312 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-3.7.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-06-01
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 400
|
||||
EPD_HEIGHT = 300
|
||||
|
||||
SCK_PIN = 10
|
||||
DIN_PIN = 11
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
|
||||
|
||||
class EPD_4in2_B:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.sck_pin = 1
|
||||
self.din_pin = 1
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
self.flag = 0
|
||||
|
||||
self.spi = SPI(1,baudrate=4000_000,sck=Pin(SCK_PIN),mosi=Pin(DIN_PIN))
|
||||
# self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
|
||||
self.EPD_4IN2B_Init()
|
||||
self.EPD_4IN2B_Clear()
|
||||
utime.sleep_ms(500)
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
def gpio_init(self):
|
||||
self.spi.deinit()
|
||||
|
||||
def spi_init(self):
|
||||
self.spi = SPI(1,baudrate=4000_000,sck=Pin(SCK_PIN),mosi=Pin(DIN_PIN))
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_read(self):
|
||||
j = 0x00
|
||||
self.sck_pin = Pin(SCK_PIN, Pin.OUT)
|
||||
self.din_pin = Pin(DIN_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
for i in range(0, 8):
|
||||
self.digital_write(self.sck_pin, 0)
|
||||
j = j << 1
|
||||
if(self.digital_read(self.din_pin) == 1):
|
||||
j = j | 0x01
|
||||
else:
|
||||
j = j & 0xfe
|
||||
self.digital_write(self.sck_pin, 1)
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
return j
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
if(self.flag == 1):
|
||||
while(self.digital_read(self.busy_pin) == 1):
|
||||
self.delay_ms(100)
|
||||
|
||||
else:
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.delay_ms(100)
|
||||
print("e-Paper busy release")
|
||||
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
if(self.flag == 1):
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xF7)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
else:
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_4IN2B_Init(self):
|
||||
i = 0x00
|
||||
self.reset()
|
||||
self.send_command(0x2F)
|
||||
|
||||
self.delay_ms(100)
|
||||
self.gpio_init()
|
||||
i = self.send_read()
|
||||
print(i)
|
||||
self.spi_init()
|
||||
|
||||
if(i == 0x01):
|
||||
self.flag = 1
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x3C)
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x18)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x11)
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x44)
|
||||
self.send_data(0x00)
|
||||
self.send_data(self.width//8-1)
|
||||
|
||||
self.send_command(0x45)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data((self.height-1)%256)
|
||||
self.send_data((self.height-1)//256)
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
|
||||
else:
|
||||
self.flag = 0
|
||||
self.send_command(0x04) # POWER_ON
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x00) # panel setting
|
||||
self.send_data(0x0f)
|
||||
|
||||
|
||||
def EPD_4IN2B_Clear(self):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
if(self.flag == 1):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([0xff] * high * wide)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1([0x00] * high * wide)
|
||||
|
||||
else:
|
||||
self.send_command(0x10)
|
||||
self.send_data1([0xff] * high * wide)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1([0x00] * high * wide)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def EPD_4IN2B_Display(self,blackImage,redImage):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
if(self.flag == 1):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(blackImage)
|
||||
|
||||
self.send_command(0x26)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(~redImage[i + j * wide])
|
||||
|
||||
else:
|
||||
self.send_command(0x10)
|
||||
self.send_data1(blackImage)
|
||||
|
||||
self.send_command(0x13)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(~redImage[i + j * wide])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Sleep(self):
|
||||
if(self.flag == 1):
|
||||
self.send_command(0X10)
|
||||
self.send_data(0x03)
|
||||
|
||||
else:
|
||||
self.send_command(0X50)
|
||||
self.send_data(0xf7)
|
||||
self.send_command(0X02)
|
||||
self.ReadBusy()
|
||||
self.send_command(0X07)
|
||||
self.send_data(0xA5)
|
||||
|
||||
if __name__=='__main__':
|
||||
|
||||
epd = EPD_4in2_B()
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0xff)
|
||||
|
||||
epd.imageblack.text("Waveshare", 5, 10, 0x00)
|
||||
epd.imagered.text("Pico_ePaper-4.2-B", 5, 40, 0x00)
|
||||
epd.imageblack.text("Raspberry Pico", 5, 70, 0x00)
|
||||
epd.EPD_4IN2B_Display(epd.buffer_black,epd.buffer_red)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.imageblack.vline(10, 90, 60, 0x00)
|
||||
epd.imagered.vline(90, 90, 60, 0x00)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imagered.hline(10, 150, 80, 0x00)
|
||||
epd.imageblack.line(10, 90, 90, 150, 0x00)
|
||||
epd.imagered.line(90, 90, 10, 150, 0x00)
|
||||
epd.EPD_4IN2B_Display(epd.buffer_black,epd.buffer_red)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.imageblack.rect(10, 180, 50, 80, 0x00)
|
||||
epd.imagered.fill_rect(70, 180, 50, 80, 0x00)
|
||||
epd.EPD_4IN2B_Display(epd.buffer_black,epd.buffer_red)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.EPD_4IN2B_Clear()
|
||||
epd.Sleep()
|
||||
|
||||
|
||||
|
||||
|
||||
310
Pico_ePaper_Code/python/Pico-ePaper-4.2-B_old.py
Normal file
310
Pico_ePaper_Code/python/Pico-ePaper-4.2-B_old.py
Normal file
@@ -0,0 +1,310 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-3.7.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-06-01
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 400
|
||||
EPD_HEIGHT = 300
|
||||
|
||||
SCK_PIN = 10
|
||||
DIN_PIN = 11
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
|
||||
|
||||
class EPD_4in2_B:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.sck_pin = 1
|
||||
self.din_pin = 1
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
self.flag = 0
|
||||
|
||||
self.spi = SPI(1,baudrate=4000_000,sck=Pin(SCK_PIN),mosi=Pin(DIN_PIN))
|
||||
# self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
|
||||
self.EPD_4IN2B_Init()
|
||||
self.EPD_4IN2B_Clear()
|
||||
utime.sleep_ms(500)
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
def gpio_init(self):
|
||||
self.spi.deinit()
|
||||
|
||||
def spi_init(self):
|
||||
self.spi = SPI(1,baudrate=4000_000,sck=Pin(SCK_PIN),mosi=Pin(DIN_PIN))
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_read(self):
|
||||
j = 0x00
|
||||
self.sck_pin = Pin(SCK_PIN, Pin.OUT)
|
||||
self.din_pin = Pin(DIN_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
for i in range(0, 8):
|
||||
self.digital_write(self.sck_pin, 0)
|
||||
j = j << 1
|
||||
if(self.digital_read(self.din_pin) == 1):
|
||||
j = j | 0x01
|
||||
else:
|
||||
j = j & 0xfe
|
||||
self.digital_write(self.sck_pin, 1)
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
return j
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
if(self.flag == 1):
|
||||
while(self.digital_read(self.busy_pin) == 1):
|
||||
self.delay_ms(100)
|
||||
|
||||
else:
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.delay_ms(100)
|
||||
print("e-Paper busy release")
|
||||
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
if(self.flag == 1):
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xF7)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
else:
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_4IN2B_Init(self):
|
||||
i = 0x00
|
||||
self.reset()
|
||||
self.send_command(0x2F)
|
||||
|
||||
self.delay_ms(100)
|
||||
self.gpio_init()
|
||||
i = self.send_read()
|
||||
print(i)
|
||||
self.spi_init()
|
||||
|
||||
if(i == 0x01):
|
||||
self.flag = 1
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x3C)
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x18)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x11)
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x44)
|
||||
self.send_data(0x00)
|
||||
self.send_data(self.width//8-1)
|
||||
|
||||
self.send_command(0x45)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data((self.height-1)%256)
|
||||
self.send_data((self.height-1)//256)
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
|
||||
else:
|
||||
self.flag = 0
|
||||
self.send_command(0x04) # POWER_ON
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x00) # panel setting
|
||||
self.send_data(0x0f)
|
||||
|
||||
|
||||
def EPD_4IN2B_Clear(self):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
if(self.flag == 1):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([0xff] * high * wide)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1([0x00] * high * wide)
|
||||
|
||||
else:
|
||||
self.send_command(0x10)
|
||||
self.send_data1([0xff] * high * wide)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1([0xff] * high * wide)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def EPD_4IN2B_Display(self,blackImage,redImage):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
if(self.flag == 1):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(blackImage)
|
||||
|
||||
self.send_command(0x26)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(~redImage[i + j * wide])
|
||||
|
||||
else:
|
||||
self.send_command(0x10)
|
||||
self.send_data1(blackImage)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1(redImage)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Sleep(self):
|
||||
if(self.flag == 1):
|
||||
self.send_command(0X10)
|
||||
self.send_data(0x03)
|
||||
|
||||
else:
|
||||
self.send_command(0X50)
|
||||
self.send_data(0xf7)
|
||||
self.send_command(0X02)
|
||||
self.ReadBusy()
|
||||
self.send_command(0X07)
|
||||
self.send_data(0xA5)
|
||||
|
||||
if __name__=='__main__':
|
||||
|
||||
epd = EPD_4in2_B()
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0xff)
|
||||
|
||||
epd.imageblack.text("Waveshare", 5, 10, 0x00)
|
||||
epd.imagered.text("Pico_ePaper-4.2-B", 5, 40, 0x00)
|
||||
epd.imageblack.text("Raspberry Pico", 5, 70, 0x00)
|
||||
epd.EPD_4IN2B_Display(epd.buffer_black,epd.buffer_red)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.imageblack.vline(10, 90, 60, 0x00)
|
||||
epd.imagered.vline(90, 90, 60, 0x00)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imagered.hline(10, 150, 80, 0x00)
|
||||
epd.imageblack.line(10, 90, 90, 150, 0x00)
|
||||
epd.imagered.line(90, 90, 10, 150, 0x00)
|
||||
epd.EPD_4IN2B_Display(epd.buffer_black,epd.buffer_red)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.imageblack.rect(10, 180, 50, 80, 0x00)
|
||||
epd.imagered.fill_rect(70, 180, 50, 80, 0x00)
|
||||
epd.EPD_4IN2B_Display(epd.buffer_black,epd.buffer_red)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.EPD_4IN2B_Clear()
|
||||
epd.Sleep()
|
||||
|
||||
|
||||
|
||||
|
||||
645
Pico_ePaper_Code/python/Pico-ePaper-4.2.py
Normal file
645
Pico_ePaper_Code/python/Pico-ePaper-4.2.py
Normal file
@@ -0,0 +1,645 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-3.7.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-06-01
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 400
|
||||
EPD_HEIGHT = 300
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
EPD_4IN2_lut_vcom0 = [
|
||||
0x00, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x00, 0x0F, 0x0F, 0x00, 0x00, 0x01,
|
||||
0x00, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
]
|
||||
EPD_4IN2_lut_ww = [
|
||||
0x50, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x90, 0x0F, 0x0F, 0x00, 0x00, 0x01,
|
||||
0xA0, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
]
|
||||
EPD_4IN2_lut_bw = [
|
||||
0x50, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x90, 0x0F, 0x0F, 0x00, 0x00, 0x01,
|
||||
0xA0, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
]
|
||||
EPD_4IN2_lut_wb = [
|
||||
0xA0, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x90, 0x0F, 0x0F, 0x00, 0x00, 0x01,
|
||||
0x50, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
]
|
||||
EPD_4IN2_lut_bb = [
|
||||
0x20, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
0x90, 0x0F, 0x0F, 0x00, 0x00, 0x01,
|
||||
0x10, 0x08, 0x08, 0x00, 0x00, 0x02,
|
||||
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********************************* #
|
||||
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,
|
||||
]
|
||||
|
||||
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,
|
||||
]
|
||||
|
||||
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,
|
||||
]
|
||||
|
||||
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,
|
||||
]
|
||||
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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,
|
||||
]
|
||||
|
||||
class EPD_4in2:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.lut_vcom0 = EPD_4IN2_lut_vcom0
|
||||
self.lut_ww = EPD_4IN2_lut_ww
|
||||
self.lut_bw = EPD_4IN2_lut_bw
|
||||
self.lut_wb = EPD_4IN2_lut_wb
|
||||
self.lut_bb = EPD_4IN2_lut_bb
|
||||
|
||||
self.lut_Partial_vcom = EPD_4IN2_Partial_lut_vcom1
|
||||
self.lut_Partial_ww = EPD_4IN2_Partial_lut_ww1
|
||||
self.lut_Partial_bw = EPD_4IN2_Partial_lut_bw1
|
||||
self.lut_Partial_wb = EPD_4IN2_Partial_lut_wb1
|
||||
self.lut_Partial_bb = EPD_4IN2_Partial_lut_bb1
|
||||
|
||||
self.lut_4Gray_vcom = EPD_4IN2_4Gray_lut_vcom
|
||||
self.lut_4Gray_ww = EPD_4IN2_4Gray_lut_ww
|
||||
self.lut_4Gray_bw = EPD_4IN2_4Gray_lut_bw
|
||||
self.lut_4Gray_wb = EPD_4IN2_4Gray_lut_wb
|
||||
self.lut_4Gray_bb = EPD_4IN2_4Gray_lut_bb
|
||||
|
||||
|
||||
self.black = 0x00
|
||||
self.white = 0xff
|
||||
self.darkgray = 0xaa
|
||||
self.grayish = 0x55
|
||||
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_1Gray_DATA = [0x00] * (self.height * self.width // 8)
|
||||
|
||||
self.buffer_1Gray = bytearray(self.height * self.width // 8)
|
||||
self.buffer_4Gray = bytearray(self.height * self.width // 4)
|
||||
self.image1Gray = framebuf.FrameBuffer(self.buffer_1Gray, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.image4Gray = framebuf.FrameBuffer(self.buffer_4Gray, self.width, self.height, framebuf.GS2_HMSB)
|
||||
|
||||
self.EPD_4IN2_Init_4Gray()
|
||||
self.EPD_4IN2_Clear()
|
||||
utime.sleep_ms(500)
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 0): # LOW: idle, HIGH: busy
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(100)
|
||||
print("e-Paper busy release")
|
||||
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_4IN2_SetLut(self):
|
||||
self.send_command(0x20)
|
||||
self.send_data1(self.lut_vcom0[0:36])
|
||||
|
||||
self.send_command(0x21)
|
||||
self.send_data1(self.lut_ww[0:36])
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data1(self.lut_bw[0:36])
|
||||
|
||||
self.send_command(0x23)
|
||||
self.send_data1(self.lut_wb[0:36])
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.lut_bb[0:36])
|
||||
|
||||
|
||||
def EPD_4IN2_Partial_SetLut(self):
|
||||
self.send_command(0x20)
|
||||
self.send_data1(self.lut_Partial_vcom[0:44])
|
||||
|
||||
self.send_command(0x21)
|
||||
self.send_data1(self.lut_Partial_ww[0:42])
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data1(self.lut_Partial_bw[0:42])
|
||||
|
||||
self.send_command(0x23)
|
||||
self.send_data1(self.lut_Partial_wb[0:42])
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.lut_Partial_bb[0:42])
|
||||
|
||||
|
||||
def EPD_4IN2_4Gray_lut(self):
|
||||
self.send_command(0x20)
|
||||
self.send_data1(self.lut_4Gray_vcom[0:42])
|
||||
|
||||
self.send_command(0x21)
|
||||
self.send_data1(self.lut_4Gray_ww[0:42])
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data1(self.lut_4Gray_bw[0:42])
|
||||
|
||||
self.send_command(0x23)
|
||||
self.send_data1(self.lut_4Gray_wb[0:42])
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.lut_4Gray_bb[0:42])
|
||||
|
||||
self.send_command(0x25)
|
||||
self.send_data1(self.lut_4Gray_ww[0:42])
|
||||
|
||||
def EPD_4IN2_Init(self):
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x01) # POWER SETTING
|
||||
self.send_data(0x03)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x2b)
|
||||
self.send_data(0x2b)
|
||||
|
||||
self.send_command(0x06) # boost soft start
|
||||
self.send_data(0x17) # A
|
||||
self.send_data(0x17) # B
|
||||
self.send_data(0x17) # C
|
||||
|
||||
self.send_command(0x04) # POWER_ON
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x00) # panel setting
|
||||
self.send_data(0xbf) # KW-BF KWR-AF BWROTP 0f BWOTP 1f
|
||||
self.send_data(0x0d)
|
||||
|
||||
self.send_command(0x30) # PLL setting
|
||||
self.send_data(0x3C) # 3A 100HZ 29 150Hz 39 200HZ 31 171HZ
|
||||
|
||||
self.send_command(0x61) # resolution setting
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x90) # 128
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x2c)
|
||||
|
||||
self.send_command(0x82) # vcom_DC setting
|
||||
self.send_data(0x28)
|
||||
|
||||
self.send_command(0X50) # VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x97) # 97white border 77black border VBDF 17|D7 VBDW 97 VBDB 57 VBDF F7 VBDW 77 VBDB 37 VBDR B7
|
||||
|
||||
self.EPD_4IN2_SetLut()
|
||||
|
||||
def EPD_4IN2_Init_4Gray(self):
|
||||
self.reset();
|
||||
self.send_command(0x01) # POWER SETTING
|
||||
self.send_data (0x03)
|
||||
self.send_data (0x00) # VGH=20V,VGL=-20V
|
||||
self.send_data (0x2b) # VDH=15V
|
||||
self.send_data (0x2b) # VDL=-15V
|
||||
self.send_data (0x13)
|
||||
|
||||
self.send_command(0x06) # booster soft start
|
||||
self.send_data (0x17) # A
|
||||
self.send_data (0x17) # B
|
||||
self.send_data (0x17) # C
|
||||
|
||||
self.send_command(0x04)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x00) # panel setting
|
||||
self.send_data(0x3f) # KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0x30) # PLL setting
|
||||
self.send_data (0x3c) # 100hz
|
||||
|
||||
self.send_command(0x61) # resolution setting
|
||||
self.send_data (0x01) # 400
|
||||
self.send_data (0x90)
|
||||
self.send_data (0x01) # 300
|
||||
self.send_data (0x2c)
|
||||
|
||||
self.send_command(0x82) # vcom_DC setting
|
||||
self.send_data (0x12)
|
||||
|
||||
self.send_command(0X50) # VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x97)
|
||||
|
||||
def EPD_4IN2_Clear(self):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(10)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def EPD_4IN2_Display(self,Image):
|
||||
self.send_command(0x13)
|
||||
self.send_data1(Image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def EPD_4IN2_PartialDisplay(self,X_start,Y_start,X_wide,Y_high,Image):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
if( X_start % 8 != 0) :
|
||||
X_start = X_start // 8 * 8 + 8
|
||||
|
||||
if( X_wide % 8 != 0) :
|
||||
X_wide = X_wide // 8 * 8 +8
|
||||
|
||||
X_end = X_start + X_wide
|
||||
Y_end = Y_start + Y_high
|
||||
|
||||
self.send_command(0X50);
|
||||
self.send_data(0xf7);
|
||||
self.delay_ms(100);
|
||||
|
||||
self.send_command(0x82) # vcom_DC setting
|
||||
self.send_data (0x08)
|
||||
self.send_command(0X50)
|
||||
self.send_data(0x47)
|
||||
self.EPD_4IN2_Partial_SetLut()
|
||||
self.send_command(0x91) # This command makes the display enter partial mode
|
||||
self.send_command(0x90) # resolution setting
|
||||
self.send_data (int(X_start/256))
|
||||
self.send_data (int(X_start)%256) # x-start
|
||||
|
||||
self.send_data (int(X_end/256))
|
||||
self.send_data (int(X_end)%256-1) # x-end
|
||||
|
||||
self.send_data (int(Y_start/256))
|
||||
self.send_data (Y_start%256) # y-start
|
||||
|
||||
self.send_data (int(Y_end/256))
|
||||
self.send_data (Y_end%256-1) # y-end
|
||||
self.send_data (0x28)
|
||||
|
||||
self.send_command(0x10); #writes Old data to SRAM for programming
|
||||
for j in range(0, Y_high):
|
||||
for i in range(0, int(X_wide/8)):
|
||||
self.send_data(self.buffer_1Gray_DATA[(Y_start + j)*wide + int(X_start/8) + i]);
|
||||
|
||||
self.send_command(0x13); #writes New data to SRAM.
|
||||
for j in range(0, Y_high):
|
||||
for i in range(0, int(X_wide/8)):
|
||||
self.send_data(~Image[(Y_start + j)*wide + int(X_start/8) + i]);
|
||||
self.buffer_1Gray_DATA[(Y_start + j)*wide + int(X_start/8) + i] = ~Image[(Y_start + j)*wide + int(X_start/8) + i]
|
||||
|
||||
self.send_command(0x12) # DISPLAY REFRESH
|
||||
self.delay_ms(10) # The delay here is necessary, 200uS at least!!!
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def EPD_4IN2_4GrayDisplay(self,Image):
|
||||
self.send_command(0x10)
|
||||
for i in range(0, 15000):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = Image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01;
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00;
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
|
||||
self.send_data(temp3)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, 15000):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = Image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01;
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00;
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
|
||||
self.send_data(temp3)
|
||||
|
||||
self.EPD_4IN2_4Gray_lut()
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def Sleep(self):
|
||||
# self.send_command(0X02) # power off
|
||||
# self.ReadBusy()
|
||||
self.send_command(0X07) # deep sleep
|
||||
self.send_data(0xA5)
|
||||
|
||||
if __name__=='__main__':
|
||||
|
||||
epd = EPD_4in2()
|
||||
|
||||
epd.image1Gray.fill(0xff)
|
||||
epd.image4Gray.fill(0xff)
|
||||
|
||||
epd.image4Gray.text("Waveshare", 5, 10, epd.black)
|
||||
epd.image4Gray.text("Pico_ePaper-4.2", 5, 40, epd.black)
|
||||
epd.image4Gray.text("Raspberry Pico", 5, 70, epd.black)
|
||||
epd.EPD_4IN2_4GrayDisplay(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.vline(10, 90, 60, epd.black)
|
||||
epd.image4Gray.vline(90, 90, 60, epd.black)
|
||||
epd.image4Gray.hline(10, 90, 80, epd.black)
|
||||
epd.image4Gray.hline(10, 150, 80, epd.black)
|
||||
epd.image4Gray.line(10, 90, 90, 150, epd.black)
|
||||
epd.image4Gray.line(90, 90, 10, 150, epd.black)
|
||||
epd.EPD_4IN2_4GrayDisplay(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.rect(10, 180, 50, 80, epd.black)
|
||||
epd.image4Gray.fill_rect(70, 180, 50, 80, epd.black)
|
||||
epd.EPD_4IN2_4GrayDisplay(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
epd.image4Gray.fill_rect(150, 10, 250, 30, epd.black)
|
||||
epd.image4Gray.text('GRAY1 with black background',155, 21, epd.white)
|
||||
epd.image4Gray.text('GRAY2 with white background',155, 51, epd.grayish)
|
||||
epd.image4Gray.text('GRAY3 with white background',155, 81, epd.darkgray)
|
||||
epd.image4Gray.text('GRAY4 with white background',155, 111, epd.black)
|
||||
epd.EPD_4IN2_4GrayDisplay(epd.buffer_4Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
# print("Support for partial refresh, but the refresh effect is not good, but it is not recommended\r\n")
|
||||
# print("Partial refresh\r\n")
|
||||
# epd.EPD_4IN2_Init()
|
||||
# for i in range(0, 10):
|
||||
# print(str(i))
|
||||
# epd.image1Gray.fill_rect(0, 200, 10, 10, epd.white)
|
||||
# epd.image1Gray.text(str(i), 2, 201, epd.black)
|
||||
# epd.EPD_4IN2_PartialDisplay(0, 200, 10, 10, epd.buffer_1Gray)
|
||||
|
||||
epd.EPD_4IN2_Init()
|
||||
epd.EPD_4IN2_Clear()
|
||||
|
||||
|
||||
|
||||
|
||||
epd.Sleep()
|
||||
|
||||
|
||||
|
||||
534
Pico_ePaper_Code/python/Pico-ePaper-4.2_V2.py
Normal file
534
Pico_ePaper_Code/python/Pico-ePaper-4.2_V2.py
Normal file
@@ -0,0 +1,534 @@
|
||||
# *****************************************************************************
|
||||
# * | File : epd4in2_V2.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2023-09-13
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 400
|
||||
EPD_HEIGHT = 300
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
LUT_ALL=[ 0x01, 0x0A, 0x1B, 0x0F, 0x03, 0x01, 0x01,
|
||||
0x05, 0x0A, 0x01, 0x0A, 0x01, 0x01, 0x01,
|
||||
0x05, 0x08, 0x03, 0x02, 0x04, 0x01, 0x01,
|
||||
0x01, 0x04, 0x04, 0x02, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x0A, 0x1B, 0x0F, 0x03, 0x01, 0x01,
|
||||
0x05, 0x4A, 0x01, 0x8A, 0x01, 0x01, 0x01,
|
||||
0x05, 0x48, 0x03, 0x82, 0x84, 0x01, 0x01,
|
||||
0x01, 0x84, 0x84, 0x82, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x0A, 0x1B, 0x8F, 0x03, 0x01, 0x01,
|
||||
0x05, 0x4A, 0x01, 0x8A, 0x01, 0x01, 0x01,
|
||||
0x05, 0x48, 0x83, 0x82, 0x04, 0x01, 0x01,
|
||||
0x01, 0x04, 0x04, 0x02, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x8A, 0x1B, 0x8F, 0x03, 0x01, 0x01,
|
||||
0x05, 0x4A, 0x01, 0x8A, 0x01, 0x01, 0x01,
|
||||
0x05, 0x48, 0x83, 0x02, 0x04, 0x01, 0x01,
|
||||
0x01, 0x04, 0x04, 0x02, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x8A, 0x9B, 0x8F, 0x03, 0x01, 0x01,
|
||||
0x05, 0x4A, 0x01, 0x8A, 0x01, 0x01, 0x01,
|
||||
0x05, 0x48, 0x03, 0x42, 0x04, 0x01, 0x01,
|
||||
0x01, 0x04, 0x04, 0x42, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x02, 0x00, 0x00, 0x07, 0x17, 0x41, 0xA8,
|
||||
0x32, 0x30 ]
|
||||
|
||||
class EPD_4in2:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
self.Seconds_1_5S = 0
|
||||
self.Seconds_1S = 1
|
||||
self.LUT_ALL = LUT_ALL
|
||||
|
||||
self.black = 0x00
|
||||
self.white = 0xff
|
||||
self.darkgray = 0xaa
|
||||
self.grayish = 0x55
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_1Gray = bytearray(self.height * self.width // 8)
|
||||
self.buffer_4Gray = bytearray(self.height * self.width // 4)
|
||||
self.image1Gray = framebuf.FrameBuffer(self.buffer_1Gray, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.image4Gray = framebuf.FrameBuffer(self.buffer_4Gray, self.width, self.height, framebuf.GS2_HMSB)
|
||||
|
||||
self.EPD_4IN2_V2_Init()
|
||||
self.EPD_4IN2_V2_Clear()
|
||||
utime.sleep_ms(500)
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 1): # LOW: idle, HIGH: busy
|
||||
self.delay_ms(100)
|
||||
print("e-Paper busy release")
|
||||
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xF7)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Fast(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Partial(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xFF)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_4GRAY(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xCF)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_4IN2_V2_Init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x40)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C) # BorderWavefrom
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x03) # X-mode
|
||||
|
||||
self.send_command(0x44)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x31)
|
||||
|
||||
self.send_command(0x45)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x2B)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_4IN2_V2_Init_Fast(self, mode):
|
||||
self.reset()
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x40)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C) # BorderWavefrom
|
||||
self.send_data(0x05)
|
||||
|
||||
if mode == self.Seconds_1_5S:
|
||||
self.send_command(0x1A)
|
||||
self.send_data(0x6E)
|
||||
else :
|
||||
self.send_command(0x1A)
|
||||
self.send_data(0x5A)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0x91)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x03) # X-mode
|
||||
|
||||
self.send_command(0x44)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x31)
|
||||
|
||||
self.send_command(0x45)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x2B)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
|
||||
def Lut(self):
|
||||
self.send_command(0x32)
|
||||
for i in range(227):
|
||||
self.send_data(self.LUT_ALL[i])
|
||||
|
||||
self.send_command(0x3F)
|
||||
self.send_data(self.LUT_ALL[227])
|
||||
|
||||
self.send_command(0x03)
|
||||
self.send_data(self.LUT_ALL[228])
|
||||
|
||||
self.send_command(0x04)
|
||||
self.send_data(self.LUT_ALL[229])
|
||||
self.send_data(self.LUT_ALL[230])
|
||||
self.send_data(self.LUT_ALL[231])
|
||||
|
||||
self.send_command(0x2c)
|
||||
self.send_data(self.LUT_ALL[232])
|
||||
|
||||
def EPD_4IN2_V2_Init_4Gray(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C) # BorderWavefrom
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x0C) # BTST
|
||||
self.send_data(0x8B) # 8B
|
||||
self.send_data(0x9C) # 9C
|
||||
self.send_data(0xA4) # 96 A4
|
||||
self.send_data(0x0F) # 0F
|
||||
|
||||
self.Lut()
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x03) # X-mode
|
||||
|
||||
self.send_command(0x44)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x31)
|
||||
|
||||
self.send_command(0x45)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x2B)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
|
||||
def EPD_4IN2_V2_Clear(self):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x24)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x26)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def EPD_4IN2_V2_Display(self,Image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(Image)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(Image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def EPD_4IN2_V2_Display_Fast(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay_Fast()
|
||||
|
||||
def EPD_4IN2_V2_PartialDisplay(self, Image):
|
||||
self.send_command(0x3C) # BorderWavefrom
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C) # BorderWavefrom
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x44)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x31)
|
||||
|
||||
self.send_command(0x45)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x2B)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x4E)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x4F)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1(Image)
|
||||
self.TurnOnDisplay_Partial()
|
||||
|
||||
|
||||
def EPD_4IN2_V2_4GrayDisplay(self,Image):
|
||||
self.send_command(0x24)
|
||||
for i in range(0, 15000):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = Image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
self.send_data(temp3)
|
||||
|
||||
self.send_command(0x26)
|
||||
for i in range(0, 15000):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = Image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
self.send_data(temp3)
|
||||
self.TurnOnDisplay_4GRAY()
|
||||
|
||||
def Sleep(self):
|
||||
self.send_command(0x10) # DEEP_SLEEP
|
||||
self.send_data(0x01)
|
||||
|
||||
if __name__=='__main__':
|
||||
|
||||
epd = EPD_4in2()
|
||||
|
||||
epd.image1Gray.fill(0xff)
|
||||
epd.image4Gray.fill(0xff)
|
||||
|
||||
print("Full brush")
|
||||
epd.EPD_4IN2_V2_Init()
|
||||
epd.image1Gray.text("Waveshare", 5, 10, epd.black)
|
||||
epd.image1Gray.text("Pico_ePaper-4.2", 5, 40, epd.black)
|
||||
epd.image1Gray.text("Raspberry Pico", 5, 70, epd.black)
|
||||
epd.EPD_4IN2_V2_Display(epd.buffer_1Gray)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.image1Gray.vline(10, 90, 60, epd.black)
|
||||
epd.image1Gray.vline(90, 90, 60, epd.black)
|
||||
epd.image1Gray.hline(10, 90, 80, epd.black)
|
||||
epd.image1Gray.hline(10, 150, 80, epd.black)
|
||||
epd.image1Gray.line(10, 90, 90, 150, epd.black)
|
||||
epd.image1Gray.line(90, 90, 10, 150, epd.black)
|
||||
epd.EPD_4IN2_V2_Display(epd.buffer_1Gray)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
print("Quick refresh")
|
||||
epd.EPD_4IN2_V2_Init_Fast(epd.Seconds_1_5S)
|
||||
epd.image1Gray.rect(10, 180, 50, 80, epd.black)
|
||||
epd.image1Gray.fill_rect(70, 180, 50, 80, epd.black)
|
||||
epd.EPD_4IN2_V2_Display_Fast(epd.buffer_1Gray)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
print("partial refresh")
|
||||
for i in range(0, 10):
|
||||
print(str(i))
|
||||
epd.image1Gray.fill_rect(60, 270, 10, 10, epd.white)
|
||||
epd.image1Gray.text(str(i), 62, 272, epd.black)
|
||||
epd.EPD_4IN2_V2_PartialDisplay(epd.buffer_1Gray)
|
||||
epd.delay_ms(500)
|
||||
|
||||
print("Four grayscale refresh")
|
||||
epd.EPD_4IN2_V2_Init_4Gray()
|
||||
epd.image4Gray.fill_rect(150, 10, 250, 30, epd.black)
|
||||
epd.image4Gray.text('GRAY1 with black background',155, 21, epd.white)
|
||||
epd.image4Gray.text('GRAY2 with white background',155, 51, epd.grayish)
|
||||
epd.image4Gray.text('GRAY3 with white background',155, 81, epd.darkgray)
|
||||
epd.image4Gray.text('GRAY4 with white background',155, 111, epd.black)
|
||||
epd.EPD_4IN2_V2_4GrayDisplay(epd.buffer_4Gray)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
print("Clear")
|
||||
epd.EPD_4IN2_V2_Init()
|
||||
epd.EPD_4IN2_V2_Clear()
|
||||
|
||||
print("Enter sleep mode ")
|
||||
epd.Sleep()
|
||||
|
||||
|
||||
|
||||
290
Pico_ePaper_Code/python/Pico-ePaper-5.65f.py
Normal file
290
Pico_ePaper_Code/python/Pico-ePaper-5.65f.py
Normal file
@@ -0,0 +1,290 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-5.65.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-06-04
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 600
|
||||
EPD_HEIGHT = 448
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_5in65(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.Black = 0x00
|
||||
self.White = 0x01
|
||||
self.Green = 0x02
|
||||
self.Blue = 0x03
|
||||
self.Red = 0x04
|
||||
self.Yellow = 0x05
|
||||
self.Orange = 0x06
|
||||
self.Clean = 0x07
|
||||
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 2)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.GS4_HMSB)
|
||||
|
||||
self.EPD_5IN65F_Init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(1)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def BusyHigh(self):
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.delay_ms(1)
|
||||
|
||||
def BusyLow(self):
|
||||
while(self.digital_read(self.busy_pin) == 1):
|
||||
self.delay_ms(1)
|
||||
|
||||
def EPD_5IN65F_Init(self):
|
||||
|
||||
self.reset();
|
||||
self.BusyHigh();
|
||||
self.send_command(0x00);
|
||||
self.send_data(0xEF);
|
||||
self.send_data(0x08);
|
||||
self.send_command(0x01);
|
||||
self.send_data(0x37);
|
||||
self.send_data(0x00);
|
||||
self.send_data(0x23);
|
||||
self.send_data(0x23);
|
||||
self.send_command(0x03);
|
||||
self.send_data(0x00);
|
||||
self.send_command(0x06);
|
||||
self.send_data(0xC7);
|
||||
self.send_data(0xC7);
|
||||
self.send_data(0x1D);
|
||||
self.send_command(0x30);
|
||||
self.send_data(0x3C);
|
||||
self.send_command(0x41);
|
||||
self.send_data(0x00);
|
||||
self.send_command(0x50);
|
||||
self.send_data(0x37);
|
||||
self.send_command(0x60);
|
||||
self.send_data(0x22);
|
||||
self.send_command(0x61);
|
||||
self.send_data(0x02);
|
||||
self.send_data(0x58);
|
||||
self.send_data(0x01);
|
||||
self.send_data(0xC0);
|
||||
self.send_command(0xE3);
|
||||
self.send_data(0xAA);
|
||||
|
||||
self.delay_ms(100);
|
||||
self.send_command(0x50);
|
||||
self.send_data(0x37);
|
||||
|
||||
def EPD_5IN65F_Clear(self,color):
|
||||
|
||||
self.send_command(0x61) # Set Resolution setting
|
||||
self.send_data(0x02)
|
||||
self.send_data(0x58)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0xC0)
|
||||
self.send_command(0x10)
|
||||
for i in range(0,int(self.width / 2)):
|
||||
self.send_data1([(color<<4)|color] * self.height)
|
||||
|
||||
self.send_command(0x04) # 0x04
|
||||
self.BusyHigh()
|
||||
self.send_command(0x12) # 0x12
|
||||
self.BusyHigh()
|
||||
self.send_command(0x02) # 0x02
|
||||
self.BusyLow()
|
||||
self.delay_ms(500)
|
||||
|
||||
def EPD_5IN65F_Display(self,image):
|
||||
|
||||
self.send_command(0x61) # Set Resolution setting
|
||||
self.send_data(0x02)
|
||||
self.send_data(0x58)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0xC0)
|
||||
self.send_command(0x10)
|
||||
|
||||
for i in range(0, int(self.width // 2)):
|
||||
self.send_data1(image[(i*self.height):((i+1)*self.height)])
|
||||
|
||||
self.send_command(0x04) # 0x04
|
||||
self.BusyHigh()
|
||||
self.send_command(0x12) # 0x12
|
||||
self.BusyHigh()
|
||||
self.send_command(0x02) # 0x02
|
||||
self.BusyLow()
|
||||
self.delay_ms(200)
|
||||
|
||||
def EPD_5IN65F_Display_part(self,image,xstart,ystart,image_width,image_heigh):
|
||||
|
||||
self.send_command(0x61) # Set Resolution setting
|
||||
self.send_data(0x02)
|
||||
self.send_data(0x58)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0xC0)
|
||||
self.send_command(0x10)
|
||||
for i in range(0, self.height):
|
||||
for j in range(0, int(self.width / 2)):
|
||||
if((i<(image_heigh+ystart)) & (i>(ystart-1) ) & (j<(image_width+xstart)/2) & (j>(xstart/2 - 1))):
|
||||
self.send_data(image[(j-xstart/2) + (image_width/2*(i-ystart))])
|
||||
else:
|
||||
self.send_data(0x11)
|
||||
|
||||
self.send_command(0x04) # 0x04
|
||||
self.BusyHigh()
|
||||
self.send_command(0x12) # 0x12
|
||||
self.BusyHigh()
|
||||
self.send_command(0x02) # 0x02
|
||||
self.BusyLow()
|
||||
self.delay_ms(200)
|
||||
|
||||
|
||||
|
||||
def Sleep(self):
|
||||
self.delay_ms(100);
|
||||
self.send_command(0x07);
|
||||
self.send_data(0xA5);
|
||||
self.delay_ms(100);
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
|
||||
if __name__=='__main__':
|
||||
|
||||
epd = EPD_5in65()
|
||||
|
||||
epd.fill(0xff)
|
||||
|
||||
epd.text("Waveshare", 5, 5, epd.Black)
|
||||
epd.text("Pico_ePaper-5.65", 5, 20, epd.Black)
|
||||
epd.text("Raspberry Pico", 5, 35, epd.Black)
|
||||
# epd.EPD_5IN65F_Display(epd.buffer)
|
||||
# epd.delay_ms(5000)
|
||||
|
||||
epd.vline(10, 60, 60, epd.Black)
|
||||
epd.vline(90, 60, 60, epd.Black)
|
||||
epd.hline(10, 60, 80, epd.Black)
|
||||
epd.hline(10, 120, 80, epd.Black)
|
||||
epd.line(10, 60, 90, 120, epd.Black)
|
||||
epd.line(90, 60, 10, 120, epd.Black)
|
||||
# epd.EPD_5IN65F_Display(epd.buffer)
|
||||
# epd.delay_ms(5000)
|
||||
|
||||
epd.rect(10, 136, 50, 80, epd.Black)
|
||||
epd.fill_rect(70, 136, 50, 80, epd.Black)
|
||||
# epd.EPD_5IN65F_Display(epd.buffer)
|
||||
# epd.delay_ms(5000)
|
||||
#
|
||||
epd.text('Black',200,11,epd.Black)
|
||||
epd.fill_rect(300, 0, 300, 30, epd.Black)
|
||||
epd.text('White',200,41,epd.White)
|
||||
epd.fill_rect(300, 30, 300, 30, epd.White)
|
||||
epd.text('Green',200,71,epd.Green)
|
||||
epd.fill_rect(300, 60, 300, 30, epd.Green)
|
||||
epd.text('Blue',200,101,epd.Blue)
|
||||
epd.fill_rect(300, 90, 300, 30, epd.Blue)
|
||||
epd.text('Red',200,131,epd.Red)
|
||||
epd.fill_rect(300, 120, 300, 30, epd.Red)
|
||||
epd.text('Yellow',200,161,epd.Yellow)
|
||||
epd.fill_rect(300, 150, 300, 30, epd.Yellow)
|
||||
epd.text('Orange',200,191,epd.Orange)
|
||||
epd.fill_rect(300, 180, 300, 30, epd.Orange)
|
||||
epd.text('Clean',200,221,epd.Black)
|
||||
epd.fill_rect(300, 210, 300, 30, epd.Clean)
|
||||
# epd.EPD_5IN65F_Display(epd.buffer)
|
||||
# epd.delay_ms(5000)
|
||||
|
||||
j = 0
|
||||
for i in range(-250,600):
|
||||
epd.line(i, 238, i+250, 448, j)
|
||||
if (i%30==0) :
|
||||
j = j+1
|
||||
j = j%7
|
||||
epd.EPD_5IN65F_Display(epd.buffer)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.EPD_5IN65F_Clear(epd.White)
|
||||
|
||||
epd.Sleep()
|
||||
|
||||
|
||||
|
||||
216
Pico_ePaper_Code/python/Pico-ePaper-5.83-B.py
Normal file
216
Pico_ePaper_Code/python/Pico-ePaper-5.83-B.py
Normal file
@@ -0,0 +1,216 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-5.83-B.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-27
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 648
|
||||
EPD_HEIGHT = 480
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
|
||||
class EPD_5in83_B():
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte(data)
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 0): # 1: idle, 0: busy
|
||||
self.delay_ms(10)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x01) #POWER SETTING
|
||||
self.send_data (0x07)
|
||||
self.send_data (0x07) #VGH=20V,VGL=-20V
|
||||
self.send_data (0x3f) #VDH=15V
|
||||
self.send_data (0x3f) #VDL=-15V
|
||||
|
||||
self.send_command(0x04) #POWER ON
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy() #waiting for the electronic paper IC to release the idle signal
|
||||
|
||||
self.send_command(0X00) #PANNEL SETTING
|
||||
self.send_data(0x0F) #KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0x61) #tres
|
||||
self.send_data (0x02) #source 648
|
||||
self.send_data (0x88)
|
||||
self.send_data (0x01) #gate 480
|
||||
self.send_data (0xe0)
|
||||
|
||||
self.send_command(0X15)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0X50) #VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x11)
|
||||
self.send_data(0x07)
|
||||
|
||||
self.send_command(0X60) #TCON SETTING
|
||||
self.send_data(0x22)
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
def display(self, imageBlack, imageRed):
|
||||
if (imageBlack == None or imageRed == None):
|
||||
return
|
||||
self.send_command(0x10) # WRITE_RAM
|
||||
self.send_data1(imageBlack)
|
||||
self.send_command(0x13) # WRITE_RAM
|
||||
self.send_data1(imageRed)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def Clear(self, colorBalck, colorRed):
|
||||
self.send_command(0x10) # WRITE_RAM
|
||||
for i in range(0, int(self.width / 8)):
|
||||
self.send_data1([colorBalck] * self.height)
|
||||
|
||||
self.send_command(0x13) # WRITE_RAM
|
||||
for i in range(0, int(self.width / 8)):
|
||||
self.send_data1([colorRed] * self.height)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x02) # DEEP_SLEEP_MODE
|
||||
self.ReadBusy()
|
||||
self.send_command(0x07)
|
||||
self.send_data(0xa5)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_5in83_B()
|
||||
epd.Clear(0xff, 0x00)
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0x00)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imagered.text("ePaper-5.83-B", 0, 25, 0xff)
|
||||
epd.imageblack.text("RPi Pico", 0, 40, 0x00)
|
||||
epd.imagered.text("Hello World", 0, 55, 0xff)
|
||||
epd.display(epd.buffer_black, epd.buffer_red)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imagered.vline(10, 90, 40, 0xff)
|
||||
epd.imagered.vline(90, 90, 40, 0xff)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imageblack.hline(10, 130, 80, 0x00)
|
||||
epd.imagered.line(10, 90, 90, 130, 0xff)
|
||||
epd.imageblack.line(90, 90, 10, 130, 0x00)
|
||||
epd.display(epd.buffer_black, epd.buffer_red)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageblack.rect(10, 150, 40, 40, 0x00)
|
||||
epd.imagered.fill_rect(60, 150, 40, 40, 0xff)
|
||||
epd.display(epd.buffer_black, epd.buffer_red)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
for i in range(0, 5):
|
||||
epd.imageblack.fill_rect(200+100, i*20, 100, 10, 0x00)
|
||||
for i in range(0, 5):
|
||||
epd.imagered.fill_rect(200+0, i*20+100, 100, 10, 0xff)
|
||||
epd.display(epd.buffer_black, epd.buffer_red)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.Clear(0xff, 0x00)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
204
Pico_ePaper_Code/python/Pico-ePaper-5.83.py
Normal file
204
Pico_ePaper_Code/python/Pico-ePaper-5.83.py
Normal file
@@ -0,0 +1,204 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-5.83.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-27
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 648
|
||||
EPD_HEIGHT = 480
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
|
||||
class EPD_5in83(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte(data)
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 0): # 1: idle, 0: busy
|
||||
self.delay_ms(10)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x01) #POWER SETTING
|
||||
self.send_data (0x07)
|
||||
self.send_data (0x07) #VGH=20V,VGL=-20V
|
||||
self.send_data (0x3f) #VDH=15V
|
||||
self.send_data (0x3f) #VDL=-15V
|
||||
|
||||
self.send_command(0x04) #POWER ON
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy() #waiting for the electronic paper IC to release the idle signal
|
||||
|
||||
self.send_command(0X00) #PANNEL SETTING
|
||||
self.send_data(0x1F) #KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0x61) #tres
|
||||
self.send_data (0x02) #source 648
|
||||
self.send_data (0x88)
|
||||
self.send_data (0x01) #gate 480
|
||||
self.send_data (0xE0)
|
||||
|
||||
self.send_command(0X15)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0X50) #VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x10)
|
||||
self.send_data(0x07)
|
||||
|
||||
self.send_command(0X60) #TCON SETTING
|
||||
self.send_data(0x22)
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
def display(self, image):
|
||||
if (image == None):
|
||||
return
|
||||
self.send_command(0x13) # WRITE_RAM
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def Clear(self, color):
|
||||
self.send_command(0x13) # WRITE_RAM
|
||||
for i in range(0, int(self.width / 8)):
|
||||
self.send_data1([color] * self.height)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x02) # DEEP_SLEEP_MODE
|
||||
self.ReadBusy()
|
||||
self.send_command(0x07)
|
||||
self.send_data(0xa5)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_5in83()
|
||||
epd.Clear(0x00)
|
||||
|
||||
epd.fill(0x00)
|
||||
epd.text("Waveshare", 5, 10, 0xff)
|
||||
epd.text("Pico_ePaper-5.83", 5, 40, 0xff)
|
||||
epd.text("Raspberry Pico", 5, 70, 0xff)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(10, 90, 60, 0xff)
|
||||
epd.vline(120, 90, 60, 0xff)
|
||||
epd.hline(10, 90, 110, 0xff)
|
||||
epd.hline(10, 150, 110, 0xff)
|
||||
epd.line(10, 90, 120, 150, 0xff)
|
||||
epd.line(120, 90, 10, 150, 0xff)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(10, 180, 50, 80, 0xff)
|
||||
epd.fill_rect(70, 180, 50, 80, 0xff)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.fill_rect(200, 100, 400, 100, 0xff)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.init()
|
||||
epd.Clear(0x00)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
417
Pico_ePaper_Code/python/Pico-ePaper-7.5-B.py
Normal file
417
Pico_ePaper_Code/python/Pico-ePaper-7.5-B.py
Normal file
@@ -0,0 +1,417 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-7.5-B.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-27
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 800
|
||||
EPD_HEIGHT = 480
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_7in5_B:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
self.partFlag=1
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def WaitUntilIdle(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 0): # Wait until the busy_pin goes LOW
|
||||
self.delay_ms(20)
|
||||
self.delay_ms(20)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12) # DISPLAY REFRESH
|
||||
self.delay_ms(100) #!!!The delay here is necessary, 200uS at least!!!
|
||||
self.WaitUntilIdle()
|
||||
|
||||
def init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x06) # btst
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x28) # If an exception is displayed, try using 0x38
|
||||
self.send_data(0x17)
|
||||
|
||||
# self.send_command(0x01) # POWER SETTING
|
||||
# self.send_data(0x07)
|
||||
# self.send_data(0x07) # VGH=20V,VGL=-20V
|
||||
# self.send_data(0x3f) # VDH=15V
|
||||
# self.send_data(0x3f) # VDL=-15V
|
||||
|
||||
self.send_command(0x04) # POWER ON
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
self.send_command(0X00) # PANNEL SETTING
|
||||
self.send_data(0x0F) # KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0x61) # tres
|
||||
self.send_data(0x03) # source 800
|
||||
self.send_data(0x20)
|
||||
self.send_data(0x01) # gate 480
|
||||
self.send_data(0xE0)
|
||||
|
||||
self.send_command(0X15)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0X50) # VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x11)
|
||||
self.send_data(0x07)
|
||||
|
||||
self.send_command(0X60) # TCON SETTING
|
||||
self.send_data(0x22)
|
||||
|
||||
self.send_command(0x65) # Resolution setting
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00) # 800*480
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
return 0;
|
||||
|
||||
def init_Fast(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.send_command(0X00)
|
||||
self.send_data(0x0F)
|
||||
|
||||
self.send_command(0x04)
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
self.send_command(0x06)
|
||||
self.send_data(0x27)
|
||||
self.send_data(0x27)
|
||||
self.send_data(0x18)
|
||||
self.send_data(0x17)
|
||||
|
||||
self.send_command(0xE0)
|
||||
self.send_data(0x02)
|
||||
self.send_command(0xE5)
|
||||
self.send_data(0x5A)
|
||||
|
||||
self.send_command(0X50)
|
||||
self.send_data(0x11)
|
||||
self.send_data(0x07)
|
||||
|
||||
return 0
|
||||
|
||||
def init_part(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.send_command(0X00)
|
||||
self.send_data(0x1F)
|
||||
|
||||
self.send_command(0x04)
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
self.send_command(0xE0)
|
||||
self.send_data(0x02)
|
||||
self.send_command(0xE5)
|
||||
self.send_data(0x6E)
|
||||
|
||||
self.send_command(0X50)
|
||||
self.send_data(0xA9)
|
||||
self.send_data(0x07)
|
||||
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
|
||||
def Clear(self):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def ClearRed(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def ClearBlack(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
# send black data
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1(self.buffer_black[(i * high) : ((i+1) * high)])
|
||||
|
||||
# send red data
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1(self.buffer_red[(i * high) : ((i+1) * high)])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Base_color(self, color):
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
self.send_command(0x10) #Write Black and White image to RAM
|
||||
for j in range(Height):
|
||||
for i in range(Width):
|
||||
self.send_data(color)
|
||||
|
||||
self.send_command(0x13) #Write Black and White image to RAM
|
||||
for j in range(Height):
|
||||
for i in range(Width):
|
||||
self.send_data(~color)
|
||||
|
||||
# self.send_command(0x12)
|
||||
# self.delay_ms(100)
|
||||
# self.WaitUntilIdle()
|
||||
|
||||
|
||||
def display_Partial(self, Image, Xstart, Ystart, Xend, Yend):
|
||||
if((Xstart % 8 + Xend % 8 == 8 & Xstart % 8 > Xend % 8) | Xstart % 8 + Xend % 8 == 0 | (Xend - Xstart)%8 == 0):
|
||||
Xstart = Xstart // 8 * 8
|
||||
Xend = Xend // 8 * 8
|
||||
else:
|
||||
Xstart = Xstart // 8 * 8
|
||||
if Xend % 8 == 0:
|
||||
Xend = Xend // 8 * 8
|
||||
else:
|
||||
Xend = Xend // 8 * 8 + 1
|
||||
|
||||
Width = (Xend - Xstart) // 8
|
||||
Height = Yend - Ystart
|
||||
|
||||
# self.send_command(0x50)
|
||||
# self.send_data(0xA9)
|
||||
# self.send_data(0x07)
|
||||
|
||||
self.send_command(0x91) #This command makes the display enter partial mode
|
||||
self.send_command(0x90) #resolution setting
|
||||
self.send_data (Xstart//256)
|
||||
self.send_data (Xstart%256) #x-start
|
||||
|
||||
self.send_data ((Xend-1)//256)
|
||||
self.send_data ((Xend-1)%256) #x-end
|
||||
|
||||
self.send_data (Ystart//256) #
|
||||
self.send_data (Ystart%256) #y-start
|
||||
|
||||
self.send_data ((Yend-1)//256)
|
||||
self.send_data ((Yend-1)%256) #y-end
|
||||
self.send_data (0x01)
|
||||
|
||||
if self.partFlag == 1:
|
||||
self.partFlag = 0
|
||||
self.send_command(0x10)
|
||||
for i in range(0, Width):
|
||||
self.send_data1([0xFF] * Height)
|
||||
|
||||
self.send_command(0x13) #Write Black and White image to RAM
|
||||
for i in range(0, Width):
|
||||
self.send_data1(Image[(i * Height) : ((i+1) * Height)])
|
||||
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x02) # power off
|
||||
self.WaitUntilIdle()
|
||||
self.send_command(0x07) # deep sleep
|
||||
self.send_data(0xa5)
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_7in5_B()
|
||||
epd.Clear()
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0x00)
|
||||
|
||||
epd.imageblack.text("Waveshare", 5, 10, 0x00)
|
||||
epd.imagered.text("Pico_ePaper-7.5-B", 5, 40, 0xff)
|
||||
epd.imageblack.text("Raspberry Pico", 5, 70, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.imageblack.vline(10, 90, 60, 0x00)
|
||||
epd.imageblack.vline(120, 90, 60, 0x00)
|
||||
epd.imagered.hline(10, 90, 110, 0xff)
|
||||
epd.imagered.hline(10, 150, 110, 0xff)
|
||||
epd.imagered.line(10, 90, 120, 150, 0xff)
|
||||
epd.imagered.line(120, 90, 10, 150, 0xff)
|
||||
epd.display()
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.imageblack.rect(10, 180, 50, 80, 0x00 )
|
||||
epd.imageblack.fill_rect(70, 180, 50, 80,0x00 )
|
||||
epd.imagered.rect(10, 300, 50, 80, 0xff )
|
||||
epd.imagered.fill_rect(70, 300, 50, 80,0xff )
|
||||
epd.display()
|
||||
epd.delay_ms(5000)
|
||||
|
||||
for k in range(0, 3):
|
||||
for j in range(0, 3):
|
||||
for i in range(0, 5):
|
||||
epd.imageblack.fill_rect(200+100+j*200, i*20+k*200, 100, 10, 0x00)
|
||||
for i in range(0, 5):
|
||||
epd.imagered.fill_rect(200+0+j*200, i*20+100+k*200, 100, 10, 0xff)
|
||||
epd.display()
|
||||
epd.delay_ms(5000)
|
||||
|
||||
# # partial update
|
||||
# epd.init()
|
||||
# epd.imageblack.fill(0xff)
|
||||
# epd.display_Base_color(0xFF)
|
||||
# epd.init_part()
|
||||
# for i in range(0, 10):
|
||||
# epd.imageblack.fill_rect(175, 105, 10, 10, 0xff)
|
||||
# epd.imageblack.text(str(i), 177, 106, 0x00)
|
||||
# epd.display_Partial(epd.buffer_black, 0, 0, 800, 480)
|
||||
|
||||
epd.init()
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
|
||||
287
Pico_ePaper_Code/python/Pico-ePaper-7.5-B_old.py
Normal file
287
Pico_ePaper_Code/python/Pico-ePaper-7.5-B_old.py
Normal file
@@ -0,0 +1,287 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-7.5-B.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-27
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 800
|
||||
EPD_HEIGHT = 480
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_7in5_B:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def WaitUntilIdle(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 0): # Wait until the busy_pin goes LOW
|
||||
self.delay_ms(20)
|
||||
self.delay_ms(20)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12) # DISPLAY REFRESH
|
||||
self.delay_ms(100) #!!!The delay here is necessary, 200uS at least!!!
|
||||
self.WaitUntilIdle()
|
||||
|
||||
def init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x06) # btst
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x28) # If an exception is displayed, try using 0x38
|
||||
self.send_data(0x17)
|
||||
|
||||
# self.send_command(0x01) # POWER SETTING
|
||||
# self.send_data(0x07)
|
||||
# self.send_data(0x07) # VGH=20V,VGL=-20V
|
||||
# self.send_data(0x3f) # VDH=15V
|
||||
# self.send_data(0x3f) # VDL=-15V
|
||||
|
||||
self.send_command(0x04) # POWER ON
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
self.send_command(0X00) # PANNEL SETTING
|
||||
self.send_data(0x0F) # KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0x61) # tres
|
||||
self.send_data(0x03) # source 800
|
||||
self.send_data(0x20)
|
||||
self.send_data(0x01) # gate 480
|
||||
self.send_data(0xE0)
|
||||
|
||||
self.send_command(0X15)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0X50) # VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x11)
|
||||
self.send_data(0x07)
|
||||
|
||||
self.send_command(0X60) # TCON SETTING
|
||||
self.send_data(0x22)
|
||||
|
||||
self.send_command(0x65) # Resolution setting
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00) # 800*480
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
return 0;
|
||||
|
||||
def Clear(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def ClearRed(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def ClearBlack(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
# send black data
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1(self.buffer_black[(i * high) : ((i+1) * high)])
|
||||
|
||||
# send red data
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1(self.buffer_red[(i * high) : ((i+1) * high)])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x02) # power off
|
||||
self.WaitUntilIdle()
|
||||
self.send_command(0x07) # deep sleep
|
||||
self.send_data(0xa5)
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_7in5_B()
|
||||
epd.Clear()
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0x00)
|
||||
|
||||
epd.imageblack.text("Waveshare", 5, 10, 0x00)
|
||||
epd.imagered.text("Pico_ePaper-7.5-B", 5, 40, 0xff)
|
||||
epd.imageblack.text("Raspberry Pico", 5, 70, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.imageblack.vline(10, 90, 60, 0x00)
|
||||
epd.imageblack.vline(120, 90, 60, 0x00)
|
||||
epd.imagered.hline(10, 90, 110, 0xff)
|
||||
epd.imagered.hline(10, 150, 110, 0xff)
|
||||
epd.imagered.line(10, 90, 120, 150, 0xff)
|
||||
epd.imagered.line(120, 90, 10, 150, 0xff)
|
||||
epd.display()
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.imageblack.rect(10, 180, 50, 80, 0x00 )
|
||||
epd.imageblack.fill_rect(70, 180, 50, 80,0x00 )
|
||||
epd.imagered.rect(10, 300, 50, 80, 0xff )
|
||||
epd.imagered.fill_rect(70, 300, 50, 80,0xff )
|
||||
epd.display()
|
||||
epd.delay_ms(5000)
|
||||
|
||||
for k in range(0, 3):
|
||||
for j in range(0, 3):
|
||||
for i in range(0, 5):
|
||||
epd.imageblack.fill_rect(200+100+j*200, i*20+k*200, 100, 10, 0x00)
|
||||
for i in range(0, 5):
|
||||
epd.imagered.fill_rect(200+0+j*200, i*20+100+k*200, 100, 10, 0xff)
|
||||
epd.display()
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
|
||||
501
Pico_ePaper_Code/python/Pico-ePaper-7.5.py
Normal file
501
Pico_ePaper_Code/python/Pico-ePaper-7.5.py
Normal file
@@ -0,0 +1,501 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-7.5.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-27
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 800
|
||||
EPD_HEIGHT = 480
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_7in5:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.black = 0x00
|
||||
self.white = 0xff
|
||||
self.darkgray = 0xaa
|
||||
self.grayish = 0x55
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_1Gray = bytearray(self.height * self.width // 8)
|
||||
self.buffer_4Gray = bytearray(self.height * self.width // 4)
|
||||
|
||||
self.image1Gray = framebuf.FrameBuffer(self.buffer_1Gray, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.image4Gray = framebuf.FrameBuffer(self.buffer_4Gray, self.width, self.height, framebuf.GS2_HMSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def WaitUntilIdle(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 0): # Wait until the busy_pin goes LOW
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(20)
|
||||
self.delay_ms(20)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12) # DISPLAY REFRESH
|
||||
self.delay_ms(100) #!!!The delay here is necessary, 200uS at least!!!
|
||||
self.WaitUntilIdle()
|
||||
|
||||
def init(self):
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x06) # btst
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x28) # If an exception is displayed, try using 0x38
|
||||
self.send_data(0x17)
|
||||
|
||||
self.send_command(0x01) #POWER SETTING
|
||||
self.send_data(0x07)
|
||||
self.send_data(0x07) #VGH=20V,VGL=-20V
|
||||
self.send_data(0x28) #VDH=15V
|
||||
self.send_data(0x17) #VDL=-15V
|
||||
|
||||
self.send_command(0x04) #POWER ON
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
self.send_command(0X00) #PANNEL SETTING
|
||||
self.send_data(0x1F) #KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0x61) #tres
|
||||
self.send_data(0x03) #source 800
|
||||
self.send_data(0x20)
|
||||
self.send_data(0x01) #gate 480
|
||||
self.send_data(0xE0)
|
||||
|
||||
self.send_command(0X15)
|
||||
self.send_data(0x00)
|
||||
|
||||
# If the screen appears gray, use the annotated initialization command
|
||||
self.send_command(0X50)
|
||||
self.send_data(0x10)
|
||||
self.send_data(0x07)
|
||||
# self.send_command(0X50)
|
||||
# self.send_data(0x10)
|
||||
# self.send_data(0x17)
|
||||
# self.send_command(0X52)
|
||||
# self.send_data(0x03)
|
||||
|
||||
|
||||
self.send_command(0X60) #TCON SETTING
|
||||
self.send_data(0x22)
|
||||
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
def init_fast(self):
|
||||
self.reset()
|
||||
|
||||
self.send_command(0X00) #PANNEL SETTING
|
||||
self.send_data(0x1F) #KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
# If the screen appears gray, use the annotated initialization command
|
||||
self.send_command(0X50)
|
||||
self.send_data(0x10)
|
||||
self.send_data(0x07)
|
||||
# self.send_command(0X50)
|
||||
# self.send_data(0x10)
|
||||
# self.send_data(0x17)
|
||||
# self.send_command(0X52)
|
||||
# self.send_data(0x03)
|
||||
|
||||
|
||||
self.send_command(0x04) #POWER ON
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle() #waiting for the electronic paper IC to release the idle signal
|
||||
|
||||
#Enhanced display drive(Add 0x06 command)
|
||||
self.send_command(0x06) #Booster Soft Start
|
||||
self.send_data (0x27)
|
||||
self.send_data (0x27)
|
||||
self.send_data (0x18)
|
||||
self.send_data (0x17)
|
||||
|
||||
self.send_command(0xE0)
|
||||
self.send_data(0x02)
|
||||
self.send_command(0xE5)
|
||||
self.send_data(0x5A)
|
||||
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
def init_part(self):
|
||||
self.reset()
|
||||
|
||||
self.send_command(0X00) #PANNEL SETTING
|
||||
self.send_data(0x1F) #KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0x04) #POWER ON
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle() #waiting for the electronic paper IC to release the idle signal
|
||||
|
||||
self.send_command(0xE0)
|
||||
self.send_data(0x02)
|
||||
self.send_command(0xE5)
|
||||
self.send_data(0x6E)
|
||||
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
# The feature will only be available on screens sold after 24/10/23
|
||||
def init_4Gray(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.send_command(0X00) #PANNEL SETTING
|
||||
self.send_data(0x1F) #KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0X50)
|
||||
self.send_data(0x10)
|
||||
self.send_data(0x07)
|
||||
|
||||
self.send_command(0x04) #POWER ON
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle() #waiting for the electronic paper IC to release the idle signal
|
||||
|
||||
#Enhanced display drive(Add 0x06 command)
|
||||
self.send_command(0x06) #Booster Soft Start
|
||||
self.send_data (0x27)
|
||||
self.send_data (0x27)
|
||||
self.send_data (0x18)
|
||||
self.send_data (0x17)
|
||||
|
||||
self.send_command(0xE0)
|
||||
self.send_data(0x02)
|
||||
self.send_command(0xE5)
|
||||
self.send_data(0x5F)
|
||||
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
def Clear(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def ClearBlack(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display(self,Image):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1(Image[(i * high) : ((i+1) * high)])
|
||||
|
||||
self.send_command(0x13)
|
||||
for j in range(high):
|
||||
for i in range(wide):
|
||||
self.send_data(~Image[i + j * wide])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Partial(self, Image, Xstart, Ystart, Xend, Yend):
|
||||
if((Xstart % 8 + Xend % 8 == 8 & Xstart % 8 > Xend % 8) | Xstart % 8 + Xend % 8 == 0 | (Xend - Xstart)%8 == 0):
|
||||
Xstart = Xstart // 8 * 8
|
||||
Xend = Xend // 8 * 8
|
||||
else:
|
||||
Xstart = Xstart // 8 * 8
|
||||
if Xend % 8 == 0:
|
||||
Xend = Xend // 8 * 8
|
||||
else:
|
||||
Xend = Xend // 8 * 8 + 1
|
||||
|
||||
Width = (Xend - Xstart) // 8
|
||||
Height = Yend - Ystart
|
||||
|
||||
self.send_command(0x50)
|
||||
self.send_data(0xA9)
|
||||
self.send_data(0x07)
|
||||
|
||||
self.send_command(0x91) #This command makes the display enter partial mode
|
||||
self.send_command(0x90) #resolution setting
|
||||
self.send_data(Xstart//256)
|
||||
self.send_data(Xstart%256) #x-start
|
||||
|
||||
self.send_data((Xend-1)//256)
|
||||
self.send_data((Xend-1)%256) #x-end
|
||||
|
||||
self.send_data(Ystart//256) #
|
||||
self.send_data(Ystart%256) #y-start
|
||||
|
||||
self.send_data((Yend-1)//256)
|
||||
self.send_data((Yend-1)%256) #y-end
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x13)
|
||||
for j in range(Height):
|
||||
for i in range(Width):
|
||||
self.send_data(~Image[i + j * Width])
|
||||
|
||||
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
def display_4Gray(self, image):
|
||||
self.send_command(0x10)
|
||||
for i in range(0, 48000):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
self.send_data(temp3)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, 48000):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x01 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x00 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x01
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x00
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
self.send_data(temp3)
|
||||
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x50)
|
||||
self.send_data(0XF7)
|
||||
self.send_command(0x02) # power off
|
||||
self.WaitUntilIdle()
|
||||
self.send_command(0x07) # deep sleep
|
||||
self.send_data(0xa5)
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_7in5()
|
||||
epd.Clear()
|
||||
|
||||
epd.image1Gray.fill(0xFF)
|
||||
|
||||
epd.image1Gray.text("Waveshare", 5, 10, 0x00)
|
||||
epd.image1Gray.text("Pico_ePaper-7.5", 5, 40, 0x00)
|
||||
epd.image1Gray.text("Raspberry Pico", 5, 70, 0x00)
|
||||
epd.display(epd.buffer_1Gray)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.image1Gray.vline(10, 90, 60, 0x00)
|
||||
epd.image1Gray.vline(120, 90, 60, 0x00)
|
||||
epd.image1Gray.hline(10, 90, 110, 0x00)
|
||||
epd.image1Gray.hline(10, 150, 110, 0x00)
|
||||
epd.image1Gray.line(10, 90, 120, 150, 0x00)
|
||||
epd.image1Gray.line(120, 90, 10, 150, 0x00)
|
||||
epd.display(epd.buffer_1Gray)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.image1Gray.rect(10, 180, 50, 80, 0x00)
|
||||
epd.image1Gray.fill_rect(70, 180, 50, 80, 0x00)
|
||||
epd.display(epd.buffer_1Gray)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.image1Gray.fill_rect(250, 150, 480, 20, 0x00)
|
||||
epd.image1Gray.fill_rect(250, 310, 480, 20, 0x00)
|
||||
epd.image1Gray.fill_rect(400, 0, 20, 480, 0x00)
|
||||
epd.image1Gray.fill_rect(560, 0, 20, 480, 0x00)
|
||||
|
||||
for j in range(0, 3):
|
||||
for i in range(0, 15):
|
||||
epd.image1Gray.line(270+j*160+i, 20+j*160, 375+j*160+i, 140+j*160, 0x00)
|
||||
for i in range(0, 15):
|
||||
epd.image1Gray.line(375+j*160+i, 20+j*160, 270+j*160+i, 140+j*160, 0x00)
|
||||
for i in range(0, 15):
|
||||
epd.image1Gray.line(270+j*160, 20+j*160+i, 390+j*160, 125+j*160+i, 0x00)
|
||||
for i in range(0, 15):
|
||||
epd.image1Gray.line(270+j*160, 125+j*160+i, 390+j*160, 20+j*160+i, 0x00)
|
||||
epd.image1Gray.fill_rect(270, 190, 100, 100, 0x00)
|
||||
epd.image1Gray.fill_rect(270, 350, 100, 100, 0x00)
|
||||
epd.display(epd.buffer_1Gray)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
# epd.init_part()
|
||||
# for i in range(0, 10):
|
||||
# epd.image1Gray.fill_rect(40, 260, 40, 10, 0x00)
|
||||
# epd.image1Gray.text(str(i), 60, 260, 0xFF)
|
||||
# epd.display_Partial(epd.buffer_1Gray, 0, 0, 800, 480)
|
||||
|
||||
# # The feature will only be available on screens sold after 24/10/23
|
||||
# print("Four grayscale refresh")
|
||||
# epd.init_4Gray()
|
||||
# epd.image4Gray.fill_rect(150, 10, 250, 30, epd.black)
|
||||
# epd.image4Gray.text('GRAY1 with black background',155, 21, epd.white)
|
||||
# epd.image4Gray.text('GRAY2 with white background',155, 51, epd.grayish)
|
||||
# epd.image4Gray.text('GRAY3 with white background',155, 81, epd.darkgray)
|
||||
# epd.image4Gray.text('GRAY4 with white background',155, 111, epd.black)
|
||||
# epd.display_4Gray(epd.buffer_4Gray)
|
||||
# epd.delay_ms(5000)
|
||||
|
||||
epd.init()
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
265
Pico_ePaper_Code/python/Pico-ePaper-7.5_old.py
Normal file
265
Pico_ePaper_Code/python/Pico-ePaper-7.5_old.py
Normal file
@@ -0,0 +1,265 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-7.5.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-27
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 800
|
||||
EPD_HEIGHT = 480
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_7in5(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def WaitUntilIdle(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 0): # Wait until the busy_pin goes LOW
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(20)
|
||||
self.delay_ms(20)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12) # DISPLAY REFRESH
|
||||
self.delay_ms(100) #!!!The delay here is necessary, 200uS at least!!!
|
||||
self.WaitUntilIdle()
|
||||
|
||||
def init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x01) # POWER SETTING
|
||||
self.send_data(0x07)
|
||||
self.send_data(0x07) # VGH=20V,VGL=-20V
|
||||
self.send_data(0x3f) # VDH=15V
|
||||
self.send_data(0x3f) # VDL=-15V
|
||||
|
||||
self.send_command(0x04) # POWER ON
|
||||
self.delay_ms(100)
|
||||
self.WaitUntilIdle()
|
||||
|
||||
self.send_command(0X00) # PANNEL SETTING
|
||||
self.send_data(0x1F) # KW-3f KWR-2F BWROTP 0f BWOTP 1f
|
||||
|
||||
self.send_command(0x61) # tres
|
||||
self.send_data(0x03) # source 800
|
||||
self.send_data(0x20)
|
||||
self.send_data(0x01) # gate 480
|
||||
self.send_data(0xE0)
|
||||
|
||||
self.send_command(0X15)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0X50) # VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x10)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0X60) # TCON SETTING
|
||||
self.send_data(0x22)
|
||||
|
||||
self.send_command(0x65) # Resolution setting
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00) # 800*480
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
return 0;
|
||||
|
||||
def Clear(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def ClearBlack(self):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0x00] * high)
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1([0xff] * high)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display(self,blackimage):
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x10)
|
||||
for i in range(0, wide):
|
||||
self.send_data1(blackimage[(i * high) : ((i+1) * high)])
|
||||
|
||||
self.send_command(0x13)
|
||||
for i in range(0, wide):
|
||||
self.send_data1(blackimage[(i * high) : ((i+1) * high)])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x02) # power off
|
||||
self.WaitUntilIdle()
|
||||
self.send_command(0x07) # deep sleep
|
||||
self.send_data(0xa5)
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_7in5()
|
||||
epd.Clear()
|
||||
|
||||
epd.fill(0x00)
|
||||
|
||||
epd.text("Waveshare", 5, 10, 0xff)
|
||||
epd.text("Pico_ePaper-7.5", 5, 40, 0xff)
|
||||
epd.text("Raspberry Pico", 5, 70, 0xff)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.vline(10, 90, 60, 0xff)
|
||||
epd.vline(120, 90, 60, 0xff)
|
||||
epd.hline(10, 90, 110, 0xff)
|
||||
epd.hline(10, 150, 110, 0xff)
|
||||
epd.line(10, 90, 120, 150, 0xff)
|
||||
epd.line(120, 90, 10, 150, 0xff)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.rect(10, 180, 50, 80, 0xff)
|
||||
epd.fill_rect(70, 180, 50, 80, 0xff)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.fill_rect(250, 150, 480, 20, 0xff)
|
||||
epd.fill_rect(250, 310, 480, 20, 0xff)
|
||||
epd.fill_rect(400, 0, 20, 480, 0xff)
|
||||
epd.fill_rect(560, 0, 20, 480, 0xff)
|
||||
|
||||
for j in range(0, 3):
|
||||
for i in range(0, 15):
|
||||
epd.line(270+j*160+i, 20+j*160, 375+j*160+i, 140+j*160, 0xff)
|
||||
for i in range(0, 15):
|
||||
epd.line(375+j*160+i, 20+j*160, 270+j*160+i, 140+j*160, 0xff)
|
||||
for i in range(0, 15):
|
||||
epd.line(270+j*160, 20+j*160+i, 390+j*160, 125+j*160+i, 0xff)
|
||||
for i in range(0, 15):
|
||||
epd.line(270+j*160, 125+j*160+i, 390+j*160, 20+j*160+i, 0xff)
|
||||
epd.fill_rect(270, 190, 100, 100, 0xff)
|
||||
epd.fill_rect(270, 350, 100, 100, 0xff)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
BIN
Pico_ePaper_Code/python/Pico.uf2
Normal file
BIN
Pico_ePaper_Code/python/Pico.uf2
Normal file
Binary file not shown.
199
Pico_ePaper_Code/python/Pico_ePaper-2.13-B.py
Normal file
199
Pico_ePaper_Code/python/Pico_ePaper-2.13-B.py
Normal file
@@ -0,0 +1,199 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.13-B.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-03-16
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
|
||||
EPD_WIDTH = 104
|
||||
EPD_HEIGHT = 212
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_2in13_B:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
self.send_command(0x71)
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
self.send_command(0x04)
|
||||
self.ReadBusy()#waiting for the electronic paper IC to release the idle signal
|
||||
|
||||
self.send_command(0x00) #panel setting
|
||||
self.send_data(0x0f) #LUT from OTP,128x296
|
||||
self.send_data(0x89) #Temperature sensor, boost and other related timing settings
|
||||
|
||||
self.send_command(0x61) #resolution setting
|
||||
self.send_data (0x68)
|
||||
self.send_data (0x00)
|
||||
self.send_data (0xD4)
|
||||
|
||||
self.send_command(0X50) #VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x77) #WBmode:VBDF 17|D7 VBDW 97 VBDB 57
|
||||
# WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7
|
||||
return 0
|
||||
|
||||
def display(self):
|
||||
self.send_command(0x10)
|
||||
self.send_data1(self.buffer_black)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1(self.buffer_red)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Clear(self, colorblack, colorred):
|
||||
self.send_command(0x10)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0X50)
|
||||
self.send_data(0xf7)
|
||||
self.send_command(0X02)
|
||||
self.ReadBusy()
|
||||
self.send_command(0x07) # DEEP_SLEEP
|
||||
self.send_data(0xA5) # check code
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in13_B()
|
||||
epd.Clear(0xff, 0xff)
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0xff)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imagered.text("ePaper-2.13", 0, 25, 0x00)
|
||||
epd.imageblack.text("RPi Pico", 0, 40, 0x00)
|
||||
epd.imagered.text("Hello World", 0, 55, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imagered.vline(10, 90, 40, 0x00)
|
||||
epd.imagered.vline(90, 90, 40, 0x00)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imageblack.hline(10, 130, 80, 0x00)
|
||||
epd.imagered.line(10, 90, 90, 130, 0x00)
|
||||
epd.imageblack.line(90, 90, 10, 130, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageblack.rect(10, 150, 40, 40, 0x00)
|
||||
epd.imagered.fill_rect(60, 150, 40, 40, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.Clear(0xff, 0xff)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
415
Pico_ePaper_Code/python/Pico_ePaper-2.13-B_V4.py
Normal file
415
Pico_ePaper_Code/python/Pico_ePaper-2.13-B_V4.py
Normal file
@@ -0,0 +1,415 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.13-B_V4.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2022-08-22
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
|
||||
EPD_WIDTH = 122
|
||||
EPD_HEIGHT = 250
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_2in13_B_V4_Portrait:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
if EPD_WIDTH % 8 == 0:
|
||||
self.width = EPD_WIDTH
|
||||
else :
|
||||
self.width = (EPD_WIDTH // 8) * 8 + 8
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_balck = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_balck, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
while(self.digital_read(self.busy_pin) == 1):
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
self.delay_ms(20)
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def SetWindows(self, Xstart, Ystart, Xend, Yend):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
self.send_data((Xstart>>3) & 0xFF)
|
||||
self.send_data((Xend>>3) & 0xFF)
|
||||
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
self.send_data(Yend & 0xFF)
|
||||
self.send_data((Yend >> 8) & 0xFF)
|
||||
|
||||
def SetCursor(self, Xstart, Ystart):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(Xstart & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data(0xf9)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindows(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x3C) #BorderWaveform
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x18) #Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x80)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.ReadBusy()
|
||||
|
||||
return 0
|
||||
|
||||
def display(self):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.buffer_balck)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(self.buffer_red)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Clear(self, colorblack, colorred):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x10)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
class EPD_2in13_B_V4_Landscape:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
if EPD_WIDTH % 8 == 0:
|
||||
self.width = EPD_WIDTH
|
||||
else :
|
||||
self.width = (EPD_WIDTH // 8) * 8 + 8
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_balck = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_balck, self.height, self.width, framebuf.MONO_VLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.height, self.width, framebuf.MONO_VLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
while(self.digital_read(self.busy_pin) == 1):
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
self.delay_ms(20)
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def SetWindows(self, Xstart, Ystart, Xend, Yend):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
self.send_data((Xstart>>3) & 0xFF)
|
||||
self.send_data((Xend>>3) & 0xFF)
|
||||
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
self.send_data(Yend & 0xFF)
|
||||
self.send_data((Yend >> 8) & 0xFF)
|
||||
|
||||
def SetCursor(self, Xstart, Ystart):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(Xstart & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data(0xf9)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x07)
|
||||
|
||||
self.SetWindows(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x3C) #BorderWaveform
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x18) #Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x80)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.ReadBusy()
|
||||
|
||||
return 0
|
||||
|
||||
def display(self):
|
||||
self.send_command(0x24)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(self.buffer_balck[i + j * self.height])
|
||||
|
||||
self.send_command(0x26)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(self.buffer_red[i + j * self.height])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Clear(self, colorblack, colorred):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([colorblack] * self.height * int(self.width / 8))
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x10)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in13_B_V4_Portrait()
|
||||
epd.Clear(0xff, 0xff)
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0xff)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imagered.text("ePaper-2.13B", 0, 25, 0x00)
|
||||
epd.imageblack.text("RPi Pico", 0, 40, 0x00)
|
||||
epd.imagered.text("Hello World", 0, 55, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imagered.vline(10, 90, 40, 0x00)
|
||||
epd.imagered.vline(90, 90, 40, 0x00)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imageblack.hline(10, 130, 80, 0x00)
|
||||
epd.imagered.line(10, 90, 90, 130, 0x00)
|
||||
epd.imageblack.line(90, 90, 10, 130, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageblack.rect(10, 150, 40, 40, 0x00)
|
||||
epd.imagered.fill_rect(60, 150, 40, 40, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd = EPD_2in13_B_V4_Landscape()
|
||||
epd.Clear(0xff, 0xff)
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0xff)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imagered.text("ePaper-2.13B", 0, 20, 0x00)
|
||||
epd.imageblack.text("Raspberry Pico", 0, 30, 0x00)
|
||||
epd.imagered.text("Hello World", 0, 40, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imagered.vline(5, 55, 60, 0x00)
|
||||
epd.imagered.vline(100, 55, 60, 0x00)
|
||||
epd.imageblack.hline(5, 55, 95, 0x00)
|
||||
epd.imageblack.hline(5, 115, 95, 0x00)
|
||||
epd.imagered.line(5, 55, 100, 115, 0x00)
|
||||
epd.imageblack.line(100, 55, 5, 115, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageblack.rect(130, 10, 40, 80, 0x00)
|
||||
epd.imagered.fill_rect(190, 10, 40, 80, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.Clear(0xff, 0xff)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
198
Pico_ePaper_Code/python/Pico_ePaper-2.13-C.py
Normal file
198
Pico_ePaper_Code/python/Pico_ePaper-2.13-C.py
Normal file
@@ -0,0 +1,198 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.13-C.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-03-16
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
|
||||
EPD_WIDTH = 104
|
||||
EPD_HEIGHT = 212
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_2in13_C:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_yellow = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imageyellow = framebuf.FrameBuffer(self.buffer_yellow, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(5)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x06) # BOOSTER_SOFT_START
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
|
||||
self.send_command(0x04) # POWER_ON
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x00) # PANEL_SETTING
|
||||
self.send_data(0x8F)
|
||||
|
||||
self.send_command(0x50) # VCOM_AND_DATA_INTERVAL_SETTING
|
||||
self.send_data(0xF0)
|
||||
|
||||
self.send_command(0x61) # RESOLUTION_SETTING
|
||||
self.send_data(self.width & 0xff)
|
||||
self.send_data(self.height >> 8)
|
||||
self.send_data(self.height & 0xff)
|
||||
return 0
|
||||
|
||||
def display(self):
|
||||
self.send_command(0x10)
|
||||
self.send_data1(self.buffer_black)
|
||||
self.send_command(0x13)
|
||||
self.send_data1(self.buffer_yellow)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Clear(self, colorblack, colorred):
|
||||
self.send_command(0x10)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x02) # POWER_OFF
|
||||
self.ReadBusy()
|
||||
self.send_command(0x07) # DEEP_SLEEP
|
||||
self.send_data(0xA5) # check code
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in13_C()
|
||||
epd.Clear(0xff, 0xff)
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imageyellow.fill(0xff)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imageyellow.text("ePaper-2.13", 0, 25, 0x00)
|
||||
epd.imageblack.text("RPi Pico", 0, 40, 0x00)
|
||||
epd.imageyellow.text("Hello World", 0, 55, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageyellow.vline(10, 90, 40, 0x00)
|
||||
epd.imageyellow.vline(90, 90, 40, 0x00)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imageblack.hline(10, 130, 80, 0x00)
|
||||
epd.imageyellow.line(10, 90, 90, 130, 0x00)
|
||||
epd.imageblack.line(90, 90, 10, 130, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageblack.rect(10, 150, 40, 40, 0x00)
|
||||
epd.imageyellow.fill_rect(60, 150, 40, 40, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.Clear(0xff, 0xff)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
407
Pico_ePaper_Code/python/Pico_ePaper-2.13-D.py
Normal file
407
Pico_ePaper_Code/python/Pico_ePaper-2.13-D.py
Normal file
@@ -0,0 +1,407 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.13-D.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-14
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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
|
||||
'''
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
|
||||
EPD_WIDTH = 104
|
||||
EPD_HEIGHT = 212
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
FULL_UPDATE = 0
|
||||
PART_UPDATE = 1
|
||||
|
||||
class EPD_2in13_D(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.lut_vcomDC = EPD_2IN13D_lut_vcomDC
|
||||
self.lut_ww = EPD_2IN13D_lut_ww
|
||||
self.lut_bw = EPD_2IN13D_lut_bw
|
||||
self.lut_wb = EPD_2IN13D_lut_wb
|
||||
self.lut_bb = EPD_2IN13D_lut_bb
|
||||
|
||||
self.lut_vcom1 = EPD_2IN13D_lut_vcom1
|
||||
self.lut_ww1 = EPD_2IN13D_lut_ww1
|
||||
self.lut_bw1 = EPD_2IN13D_lut_bw1
|
||||
self.lut_wb1 = EPD_2IN13D_lut_wb1
|
||||
self.lut_bb1 = EPD_2IN13D_lut_bb1
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep_ms(delaytime)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('e-Paper busy')
|
||||
busy = 1
|
||||
self.send_command(0x71)
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(200)
|
||||
print('e-Paper busy release')
|
||||
|
||||
def SetFullReg(self):
|
||||
self.send_command(0x50)
|
||||
self.send_data(0xB7)
|
||||
|
||||
self.send_command(0x20)
|
||||
self.send_data1(self.lut_vcomDC[0:44])
|
||||
|
||||
self.send_command(0x21)
|
||||
self.send_data1(self.lut_ww[0:42])
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data1(self.lut_bw[0:42])
|
||||
|
||||
self.send_command(0x23)
|
||||
self.send_data1(self.lut_bb[0:42])
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.lut_wb[0:42])
|
||||
|
||||
|
||||
def SetPartReg(self):
|
||||
self.send_command(0x82)
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x50)
|
||||
self.send_data(0xB7)
|
||||
|
||||
self.send_command(0x20)
|
||||
self.send_data1(self.lut_vcom1[0:44])
|
||||
|
||||
self.send_command(0x21)
|
||||
self.send_data1(self.lut_ww1[0:42])
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data1(self.lut_bw1[0:42])
|
||||
|
||||
self.send_command(0x23)
|
||||
self.send_data1(self.lut_wb1[0:42])
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.lut_bb1[0:42])
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy()
|
||||
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x01)
|
||||
self.send_data(0x03)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x2B)
|
||||
self.send_data(0x2B)
|
||||
self.send_data(0x03)
|
||||
|
||||
|
||||
self.send_command(0x06)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
|
||||
self.send_command(0x04)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x00)
|
||||
self.send_data(0xBF)
|
||||
self.send_data(0x0E)
|
||||
|
||||
self.send_command(0x30)
|
||||
self.send_data(0x3A)
|
||||
|
||||
self.send_command(0x61)
|
||||
self.send_data(self.width)
|
||||
self.send_data((self.height&0x100)>>8)
|
||||
self.send_data(self.height&0xff)
|
||||
|
||||
self.send_command(0x82)
|
||||
self.send_data(0x28)
|
||||
|
||||
|
||||
def display(self, image):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
self.send_command(0x10)
|
||||
self.send_data1([0x00] * high * wide)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1(image)
|
||||
|
||||
self.SetFullReg()
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def displayPartial(self, image):
|
||||
self.SetPartReg()
|
||||
self.send_command(0x91)
|
||||
self.send_command(0x90)
|
||||
self.send_data(0)
|
||||
self.send_data(self.width - 1)
|
||||
|
||||
self.send_data(0)
|
||||
self.send_data(0)
|
||||
self.send_data(self.height//256)
|
||||
self.send_data(self.height%256 - 1)
|
||||
self.send_data(0X28)
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
self.send_command(0x10)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(~image[i + j * wide])
|
||||
self.send_command(0x13)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(image[i + j * wide])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
|
||||
def Clear(self, color):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
self.send_command(0x10)
|
||||
self.send_data1([color] * high * wide)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1([~color] * high * wide)
|
||||
|
||||
self.SetFullReg()
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x50)
|
||||
self.send_data(0xF7)
|
||||
self.send_command(0x02)
|
||||
self.send_command(0x07)
|
||||
self.send_data(0xA5)
|
||||
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in13_D()
|
||||
epd.Clear(0x00)
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 0, 10, 0x00)
|
||||
epd.text("ePaper-2.13", 0, 30, 0x00)
|
||||
epd.text("RPi Pico", 0, 50, 0x00)
|
||||
epd.text("Hello World", 0, 70, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(10, 90, 60, 0x00)
|
||||
epd.vline(90, 90, 60, 0x00)
|
||||
epd.hline(10, 90, 80, 0x00)
|
||||
epd.hline(10, 150, 80, 0x00)
|
||||
epd.line(10, 90, 90, 150, 0x00)
|
||||
epd.line(90, 90, 10, 150, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(40, 180, 40, 10, 0xff)
|
||||
epd.text(str(i), 50, 180, 0x00)
|
||||
epd.displayPartial(epd.buffer)
|
||||
|
||||
epd.Clear(0x00)
|
||||
epd.delay_ms(2000)
|
||||
epd.sleep()
|
||||
326
Pico_ePaper_Code/python/Pico_ePaper-2.13.py
Normal file
326
Pico_ePaper_Code/python/Pico_ePaper-2.13.py
Normal file
@@ -0,0 +1,326 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.13.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-03-16
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
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,
|
||||
]
|
||||
|
||||
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,
|
||||
]
|
||||
|
||||
EPD_WIDTH = 128 # 122
|
||||
EPD_HEIGHT = 250
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
FULL_UPDATE = 0
|
||||
PART_UPDATE = 1
|
||||
|
||||
class EPD_2in13(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.full_lut = lut_full_update
|
||||
self.partial_lut = lut_partial_update
|
||||
|
||||
self.full_update = FULL_UPDATE
|
||||
self.part_update = PART_UPDATE
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init(FULL_UPDATE)
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
while(self.digital_read(self.busy_pin) == 1): # 0: idle, 1: busy
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplayPart(self):
|
||||
self.send_command(0x22)
|
||||
self.send_data(0x0c)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self, update):
|
||||
print('init')
|
||||
self.reset()
|
||||
if(update == self.full_update):
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) # soft reset
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x74) #set analog block control
|
||||
self.send_data(0x54)
|
||||
self.send_command(0x7E) #set digital block control
|
||||
self.send_data(0x3B)
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data(0x27)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x01)
|
||||
|
||||
self.send_command(0x44) #set Ram-X address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x0F) #0x0C-->(15+1)*8=128
|
||||
|
||||
self.send_command(0x45) #set Ram-Y address start/end position
|
||||
self.send_data(0x27) #0xF9-->(249+1)=250
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x2e)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C) #BorderWaveform
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x2C) #VCOM Voltage
|
||||
self.send_data(0x55) #
|
||||
|
||||
self.send_command(0x03)
|
||||
self.send_data(self.full_lut[70])
|
||||
|
||||
self.send_command(0x04) #
|
||||
self.send_data(self.full_lut[71])
|
||||
self.send_data(self.full_lut[72])
|
||||
self.send_data(self.full_lut[73])
|
||||
|
||||
self.send_command(0x3A) #Dummy Line
|
||||
self.send_data(self.full_lut[74])
|
||||
self.send_command(0x3B) #Gate time
|
||||
self.send_data(self.full_lut[75])
|
||||
|
||||
self.send_command(0x32)
|
||||
for count in range(70):
|
||||
self.send_data(self.full_lut[count])
|
||||
|
||||
self.send_command(0x4E) # set RAM x address count to 0
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F) # set RAM y address count to 0X127
|
||||
self.send_data(0x0)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
else:
|
||||
self.send_command(0x2C) #VCOM Voltage
|
||||
self.send_data(0x26)
|
||||
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x32)
|
||||
for count in range(70):
|
||||
self.send_data(self.partial_lut[count])
|
||||
|
||||
self.send_command(0x37)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x40)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xC0)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x3C) #BorderWaveform
|
||||
self.send_data(0x01)
|
||||
return 0
|
||||
|
||||
def display(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def displayPartial(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplayPart()
|
||||
|
||||
def displayPartBaseImage(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def Clear(self, color):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([color] * self.height * int(self.width / 8))
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1([color] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x10) #enter deep sleep
|
||||
self.send_data(0x03)
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in13()
|
||||
epd.Clear(0xff)
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 0, 10, 0x00)
|
||||
epd.text("ePaper-2.13", 0, 30, 0x00)
|
||||
epd.text("Raspberry Pico", 0, 50, 0x00)
|
||||
epd.text("Hello World", 0, 70, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(10, 90, 60, 0x00)
|
||||
epd.vline(90, 90, 60, 0x00)
|
||||
epd.hline(10, 90, 80, 0x00)
|
||||
epd.hline(10, 150, 80, 0x00)
|
||||
epd.line(10, 90, 90, 150, 0x00)
|
||||
epd.line(90, 90, 10, 150, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(10, 180, 50, 40, 0x00)
|
||||
epd.fill_rect(60, 180, 50, 40, 0x00)
|
||||
epd.displayPartBaseImage(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.init(epd.part_update)
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(40, 230, 40, 10, 0xff)
|
||||
epd.text(str(i), 60, 230, 0x00)
|
||||
epd.displayPartial(epd.buffer)
|
||||
|
||||
epd.init(epd.full_update)
|
||||
epd.Clear(0xff)
|
||||
epd.delay_ms(2000)
|
||||
epd.sleep()
|
||||
694
Pico_ePaper_Code/python/Pico_ePaper-2.13_V3.py
Normal file
694
Pico_ePaper_Code/python/Pico_ePaper-2.13_V3.py
Normal file
@@ -0,0 +1,694 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.13_V3.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-11-01
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
WF_PARTIAL_2IN13_V3= [
|
||||
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,
|
||||
0x14,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
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,0x00,0x32,0x36,
|
||||
]
|
||||
|
||||
WS_20_30_2IN13_V3 = [
|
||||
0x80,0x4A,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0x40,0x4A,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0x80,0x4A,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0x40,0x4A,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0xF,0x0,0x0,0x0,0x0,0x0,0x0,
|
||||
0xF,0x0,0x0,0xF,0x0,0x0,0x2,
|
||||
0xF,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,
|
||||
0x22,0x22,0x22,0x22,0x22,0x22,0x0,0x0,0x0,
|
||||
0x22,0x17,0x41,0x0,0x32,0x36
|
||||
]
|
||||
|
||||
EPD_WIDTH = 122
|
||||
EPD_HEIGHT = 250
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_2in13_V3_Portrait(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
if EPD_WIDTH % 8 == 0:
|
||||
self.width = EPD_WIDTH
|
||||
else :
|
||||
self.width = (EPD_WIDTH // 8) * 8 + 8
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.full_lut = WF_PARTIAL_2IN13_V3
|
||||
self.partial_lut = WS_20_30_2IN13_V3
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
'''
|
||||
function :Change the pin state
|
||||
parameter:
|
||||
pin : pin
|
||||
value : state
|
||||
'''
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
'''
|
||||
function : Read the pin state
|
||||
parameter:
|
||||
pin : pin
|
||||
'''
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
'''
|
||||
function : The time delay function
|
||||
parameter:
|
||||
delaytime : ms
|
||||
'''
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
'''
|
||||
function : Write data to SPI
|
||||
parameter:
|
||||
data : data
|
||||
'''
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
'''
|
||||
function :Hardware reset
|
||||
parameter:
|
||||
'''
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
|
||||
'''
|
||||
function :send command
|
||||
parameter:
|
||||
command : Command register
|
||||
'''
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
'''
|
||||
function :send data
|
||||
parameter:
|
||||
data : Write data
|
||||
'''
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
'''
|
||||
function :Wait until the busy_pin goes LOW
|
||||
parameter:
|
||||
'''
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
self.delay_ms(10)
|
||||
while(self.digital_read(self.busy_pin) == 1): # 0: idle, 1: busy
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
'''
|
||||
function : Turn On Display
|
||||
parameter:
|
||||
'''
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Turn On Display Part
|
||||
parameter:
|
||||
'''
|
||||
def TurnOnDisplayPart(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0x0F) # fast:0x0c, quality:0x0f, 0xcf
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Set lut
|
||||
parameter:
|
||||
lut : lut data
|
||||
'''
|
||||
def LUT(self, lut):
|
||||
self.send_command(0x32)
|
||||
self.send_data1(lut[0:153])
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Send lut data and configuration
|
||||
parameter:
|
||||
lut : lut data
|
||||
'''
|
||||
def LUT_by_host(self, lut):
|
||||
self.LUT(lut) # lut
|
||||
self.send_command(0x3F)
|
||||
self.send_data(lut[153])
|
||||
self.send_command(0x03) # gate voltage
|
||||
self.send_data(lut[154])
|
||||
self.send_command(0x04) # source voltage
|
||||
self.send_data(lut[155]) # VSH
|
||||
self.send_data(lut[156]) # VSH2
|
||||
self.send_data(lut[157]) # VSL
|
||||
self.send_command(0x2C) # VCOM
|
||||
self.send_data(lut[158])
|
||||
|
||||
'''
|
||||
function : Setting the display window
|
||||
parameter:
|
||||
Xstart : X-axis starting position
|
||||
Ystart : Y-axis starting position
|
||||
Xend : End position of X-axis
|
||||
Yend : End position of Y-axis
|
||||
'''
|
||||
def SetWindows(self, Xstart, Ystart, Xend, Yend):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
self.send_data((Xstart >> 3) & 0xFF)
|
||||
self.send_data((Xend >> 3) & 0xFF)
|
||||
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
self.send_data(Yend & 0xFF)
|
||||
self.send_data((Yend >> 8) & 0xFF)
|
||||
|
||||
'''
|
||||
function : Set Cursor
|
||||
parameter:
|
||||
Xstart : X-axis starting position
|
||||
Ystart : Y-axis starting position
|
||||
'''
|
||||
def SetCursor(self, Xstart, Ystart):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(Xstart & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
|
||||
'''
|
||||
function : Initialize the e-Paper register
|
||||
parameter:
|
||||
'''
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
self.delay_ms(100)
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) # SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) # Driver output control
|
||||
self.send_data(0xf9)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindows(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x3C) # BorderWaveform
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x18) # Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.ReadBusy()
|
||||
self.LUT_by_host(self.partial_lut)
|
||||
|
||||
'''
|
||||
function : Clear screen
|
||||
parameter:
|
||||
'''
|
||||
def Clear(self):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([0xff] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
'''
|
||||
function : Sends the image buffer in RAM to e-Paper and displays
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def display(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
'''
|
||||
function : Refresh a base image
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def Display_Base(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
'''
|
||||
function : Sends the image buffer in RAM to e-Paper and partial refresh
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def display_Partial(self, image):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(1)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
|
||||
self.LUT_by_host(self.full_lut)
|
||||
|
||||
self.send_command(0x37)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x40)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xC0)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.SetWindows(0,0,self.width-1,self.height-1)
|
||||
self.SetCursor(0,0)
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplayPart()
|
||||
|
||||
'''
|
||||
function : Enter sleep mode
|
||||
parameter:
|
||||
'''
|
||||
def sleep(self):
|
||||
self.send_command(0x10) #enter deep sleep
|
||||
self.send_data(0x01)
|
||||
self.delay_ms(100)
|
||||
|
||||
|
||||
class EPD_2in13_V3_Landscape(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
if EPD_WIDTH % 8 == 0:
|
||||
self.width = EPD_WIDTH
|
||||
else :
|
||||
self.width = (EPD_WIDTH // 8) * 8 + 8
|
||||
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.full_lut = WF_PARTIAL_2IN13_V3
|
||||
self.partial_lut = WS_20_30_2IN13_V3
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.height, self.width, framebuf.MONO_VLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
self.delay_ms(10)
|
||||
while(self.digital_read(self.busy_pin) == 1): # 0: idle, 1: busy
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplayPart(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0x0F) # fast:0x0c, quality:0x0f, 0xcf
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def LUT(self, lut):
|
||||
self.send_command(0x32)
|
||||
self.send_data1(lut[0:153])
|
||||
self.ReadBusy()
|
||||
|
||||
def LUT_by_host(self, lut):
|
||||
self.LUT(lut) # lut
|
||||
self.send_command(0x3F)
|
||||
self.send_data(lut[153])
|
||||
self.send_command(0x03) # gate voltage
|
||||
self.send_data(lut[154])
|
||||
self.send_command(0x04) # source voltage
|
||||
self.send_data(lut[155]) # VSH
|
||||
self.send_data(lut[156]) # VSH2
|
||||
self.send_data(lut[157]) # VSL
|
||||
self.send_command(0x2C) # VCOM
|
||||
self.send_data(lut[158])
|
||||
|
||||
def SetWindows(self, Xstart, Ystart, Xend, Yend):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
self.send_data((Xstart >> 3) & 0xFF)
|
||||
self.send_data((Xend >> 3) & 0xFF)
|
||||
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
self.send_data(Yend & 0xFF)
|
||||
self.send_data((Yend >> 8) & 0xFF)
|
||||
|
||||
def SetCursor(self, Xstart, Ystart):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(Xstart & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
self.delay_ms(100)
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) # SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) # Driver output control
|
||||
self.send_data(0xf9)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x07)
|
||||
|
||||
self.SetWindows(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x3C) # BorderWaveform
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x18) # Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.ReadBusy()
|
||||
self.LUT_by_host(self.partial_lut)
|
||||
|
||||
def Clear(self):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([0xff] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display(self, image):
|
||||
self.send_command(0x24)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def Display_Base(self, image):
|
||||
self.send_command(0x24)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
|
||||
self.send_command(0x26)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Partial(self, image):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(1)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
|
||||
self.LUT_by_host(self.full_lut)
|
||||
|
||||
self.send_command(0x37)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x40)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xC0)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.SetWindows(0,0,self.width-1,self.height-1)
|
||||
self.SetCursor(0,0)
|
||||
|
||||
self.send_command(0x24)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
|
||||
self.TurnOnDisplayPart()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x10) #enter deep sleep
|
||||
self.send_data(0x01)
|
||||
self.delay_ms(100)
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in13_V3_Landscape()
|
||||
epd.Clear()
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 0, 10, 0x00)
|
||||
epd.text("ePaper-2.13_V3", 0, 20, 0x00)
|
||||
epd.text("Raspberry Pico", 0, 30, 0x00)
|
||||
epd.text("Hello World", 0, 40, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(5, 55, 60, 0x00)
|
||||
epd.vline(100, 55, 60, 0x00)
|
||||
epd.hline(5, 55, 95, 0x00)
|
||||
epd.hline(5, 115, 95, 0x00)
|
||||
epd.line(5, 55, 100, 115, 0x00)
|
||||
epd.line(100, 55, 5, 115, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(130, 10, 40, 80, 0x00)
|
||||
epd.fill_rect(190, 10, 40, 80, 0x00)
|
||||
epd.Display_Base(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.init()
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(175, 105, 10, 10, 0xff)
|
||||
epd.text(str(i), 177, 106, 0x00)
|
||||
epd.display_Partial(epd.buffer)
|
||||
|
||||
print("sleep")
|
||||
epd.init()
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
epd.sleep()
|
||||
|
||||
|
||||
|
||||
epd = EPD_2in13_V3_Portrait()
|
||||
epd.Clear()
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 0, 10, 0x00)
|
||||
epd.text("ePaper-2.13_V3", 0, 30, 0x00)
|
||||
epd.text("Raspberry Pico", 0, 50, 0x00)
|
||||
epd.text("Hello World", 0, 70, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(10, 90, 60, 0x00)
|
||||
epd.vline(90, 90, 60, 0x00)
|
||||
epd.hline(10, 90, 80, 0x00)
|
||||
epd.hline(10, 150, 80, 0x00)
|
||||
epd.line(10, 90, 90, 150, 0x00)
|
||||
epd.line(90, 90, 10, 150, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(10, 180, 50, 40, 0x00)
|
||||
epd.fill_rect(60, 180, 50, 40, 0x00)
|
||||
epd.Display_Base(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.init()
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(40, 230, 40, 10, 0xff)
|
||||
epd.text(str(i), 60, 230, 0x00)
|
||||
epd.display_Partial(epd.buffer)
|
||||
|
||||
print("sleep")
|
||||
epd.init()
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
epd.sleep()
|
||||
720
Pico_ePaper_Code/python/Pico_ePaper-2.13_V4.py
Normal file
720
Pico_ePaper_Code/python/Pico_ePaper-2.13_V4.py
Normal file
@@ -0,0 +1,720 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.13_V3.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-11-01
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
|
||||
EPD_WIDTH = 122
|
||||
EPD_HEIGHT = 250
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_2in13_V4_Portrait(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
if EPD_WIDTH % 8 == 0:
|
||||
self.width = EPD_WIDTH
|
||||
else :
|
||||
self.width = (EPD_WIDTH // 8) * 8 + 8
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
'''
|
||||
function :Change the pin state
|
||||
parameter:
|
||||
pin : pin
|
||||
value : state
|
||||
'''
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
'''
|
||||
function : Read the pin state
|
||||
parameter:
|
||||
pin : pin
|
||||
'''
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
'''
|
||||
function : The time delay function
|
||||
parameter:
|
||||
delaytime : ms
|
||||
'''
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
'''
|
||||
function : Write data to SPI
|
||||
parameter:
|
||||
data : data
|
||||
'''
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
'''
|
||||
function :Hardware reset
|
||||
parameter:
|
||||
'''
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
|
||||
'''
|
||||
function :send command
|
||||
parameter:
|
||||
command : Command register
|
||||
'''
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
'''
|
||||
function :send data
|
||||
parameter:
|
||||
data : Write data
|
||||
'''
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
'''
|
||||
function :Wait until the busy_pin goes LOW
|
||||
parameter:
|
||||
'''
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
self.delay_ms(10)
|
||||
while(self.digital_read(self.busy_pin) == 1): # 0: idle, 1: busy
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
'''
|
||||
function : Turn On Display
|
||||
parameter:
|
||||
'''
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0xf7)
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Turn On Display Fast
|
||||
parameter:
|
||||
'''
|
||||
def TurnOnDisplay_Fast(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0xC7) # fast:0x0c, quality:0x0f, 0xcf
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Turn On Display Part
|
||||
parameter:
|
||||
'''
|
||||
def TurnOnDisplayPart(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0xff) # fast:0x0c, quality:0x0f, 0xcf
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Setting the display window
|
||||
parameter:
|
||||
Xstart : X-axis starting position
|
||||
Ystart : Y-axis starting position
|
||||
Xend : End position of X-axis
|
||||
Yend : End position of Y-axis
|
||||
'''
|
||||
def SetWindows(self, Xstart, Ystart, Xend, Yend):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
self.send_data((Xstart >> 3) & 0xFF)
|
||||
self.send_data((Xend >> 3) & 0xFF)
|
||||
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
self.send_data(Yend & 0xFF)
|
||||
self.send_data((Yend >> 8) & 0xFF)
|
||||
|
||||
'''
|
||||
function : Set Cursor
|
||||
parameter:
|
||||
Xstart : X-axis starting position
|
||||
Ystart : Y-axis starting position
|
||||
'''
|
||||
def SetCursor(self, Xstart, Ystart):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(Xstart & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
|
||||
'''
|
||||
function : Initialize the e-Paper register
|
||||
parameter:
|
||||
'''
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
self.delay_ms(100)
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) # SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) # Driver output control
|
||||
self.send_data(0xf9)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindows(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x3C) # BorderWaveform
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x18) # Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Initialize the e-Paper fast register
|
||||
parameter:
|
||||
'''
|
||||
def init_fast(self):
|
||||
print('init_fast')
|
||||
self.reset()
|
||||
self.delay_ms(100)
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x18) # Read built-in temperature sensor
|
||||
self.send_command(0x80)
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindow(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0xB1)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x1A) # Write to temperature register
|
||||
self.send_data(0x64)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0x91)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
return 0
|
||||
|
||||
'''
|
||||
function : Clear screen
|
||||
parameter:
|
||||
'''
|
||||
def Clear(self):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([0xff] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
'''
|
||||
function : Sends the image buffer in RAM to e-Paper and displays
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def display(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_fast(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data2(image)
|
||||
self.TurnOnDisplay_Fast()
|
||||
|
||||
'''
|
||||
function : Refresh a base image
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def Display_Base(self, image):
|
||||
self.send_command(0x24)
|
||||
self.send_data1(image)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
'''
|
||||
function : Sends the image buffer in RAM to e-Paper and partial refresh
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def displayPartial(self, image):
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x3C) # BorderWavefrom
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x01) # Driver output control
|
||||
self.send_data(0xF9)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindows(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplayPart()
|
||||
|
||||
'''
|
||||
function : Enter sleep mode
|
||||
parameter:
|
||||
'''
|
||||
def sleep(self):
|
||||
self.send_command(0x10) #enter deep sleep
|
||||
self.send_data(0x01)
|
||||
self.delay_ms(100)
|
||||
|
||||
|
||||
class EPD_2in13_V4_Landscape(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
if EPD_WIDTH % 8 == 0:
|
||||
self.width = EPD_WIDTH
|
||||
else :
|
||||
self.width = (EPD_WIDTH // 8) * 8 + 8
|
||||
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.height, self.width, framebuf.MONO_VLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(20)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
self.delay_ms(10)
|
||||
while(self.digital_read(self.busy_pin) == 1): # 0: idle, 1: busy
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
'''
|
||||
function : Turn On Display
|
||||
parameter:
|
||||
'''
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0xf7)
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Turn On Display Fast
|
||||
parameter:
|
||||
'''
|
||||
def TurnOnDisplay_Fast(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0xC7) # fast:0x0c, quality:0x0f, 0xcf
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Turn On Display Part
|
||||
parameter:
|
||||
'''
|
||||
def TurnOnDisplayPart(self):
|
||||
self.send_command(0x22) # Display Update Control
|
||||
self.send_data(0xff) # fast:0x0c, quality:0x0f, 0xcf
|
||||
self.send_command(0x20) # Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Setting the display window
|
||||
parameter:
|
||||
Xstart : X-axis starting position
|
||||
Ystart : Y-axis starting position
|
||||
Xend : End position of X-axis
|
||||
Yend : End position of Y-axis
|
||||
'''
|
||||
def SetWindows(self, Xstart, Ystart, Xend, Yend):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
self.send_data((Xstart >> 3) & 0xFF)
|
||||
self.send_data((Xend >> 3) & 0xFF)
|
||||
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
self.send_data(Yend & 0xFF)
|
||||
self.send_data((Yend >> 8) & 0xFF)
|
||||
|
||||
'''
|
||||
function : Set Cursor
|
||||
parameter:
|
||||
Xstart : X-axis starting position
|
||||
Ystart : Y-axis starting position
|
||||
'''
|
||||
def SetCursor(self, Xstart, Ystart):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(Xstart & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(Ystart & 0xFF)
|
||||
self.send_data((Ystart >> 8) & 0xFF)
|
||||
|
||||
'''
|
||||
function : Initialize the e-Paper register
|
||||
parameter:
|
||||
'''
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
self.delay_ms(100)
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) # SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) # Driver output control
|
||||
self.send_data(0xf9)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x07)
|
||||
|
||||
self.SetWindows(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x3C) # BorderWaveform
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x18) # Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.ReadBusy()
|
||||
|
||||
'''
|
||||
function : Initialize the e-Paper fast register
|
||||
parameter:
|
||||
'''
|
||||
def init_fast(self):
|
||||
print('init_fast')
|
||||
self.reset()
|
||||
self.delay_ms(100)
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x18) # Read built-in temperature sensor
|
||||
self.send_command(0x80)
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x07)
|
||||
|
||||
self.SetWindow(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0xB1)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x1A) # Write to temperature register
|
||||
self.send_data(0x64)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0x91)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
return 0
|
||||
|
||||
'''
|
||||
function : Clear screen
|
||||
parameter:
|
||||
'''
|
||||
def Clear(self):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([0xff] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
'''
|
||||
function : Sends the image buffer in RAM to e-Paper and displays
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def display(self, image):
|
||||
self.send_command(0x24)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_fast(self, image):
|
||||
self.send_command(0x24)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
self.TurnOnDisplay_Fast()
|
||||
|
||||
'''
|
||||
function : Refresh a base image
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def Display_Base(self, image):
|
||||
self.send_command(0x24)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
|
||||
self.send_command(0x26)
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
'''
|
||||
function : Sends the image buffer in RAM to e-Paper and partial refresh
|
||||
parameter:
|
||||
image : Image data
|
||||
'''
|
||||
def displayPartial(self, image):
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x3C) # BorderWavefrom
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x01) # Driver output control
|
||||
self.send_data(0xF9)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) # data entry mode
|
||||
self.send_data(0x07)
|
||||
|
||||
self.SetWindows(0, 0, self.width-1, self.height-1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
self.TurnOnDisplayPart()
|
||||
|
||||
'''
|
||||
function : Enter sleep mode
|
||||
parameter:
|
||||
'''
|
||||
def sleep(self):
|
||||
self.send_command(0x10) #enter deep sleep
|
||||
self.send_data(0x01)
|
||||
self.delay_ms(100)
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in13_V4_Landscape()
|
||||
epd.Clear()
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 0, 10, 0x00)
|
||||
epd.text("ePaper-2.13_V4", 0, 20, 0x00)
|
||||
epd.text("Raspberry Pico", 0, 30, 0x00)
|
||||
epd.text("Hello World", 0, 40, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(5, 55, 60, 0x00)
|
||||
epd.vline(100, 55, 60, 0x00)
|
||||
epd.hline(5, 55, 95, 0x00)
|
||||
epd.hline(5, 115, 95, 0x00)
|
||||
epd.line(5, 55, 100, 115, 0x00)
|
||||
epd.line(100, 55, 5, 115, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(130, 10, 40, 80, 0x00)
|
||||
epd.fill_rect(190, 10, 40, 80, 0x00)
|
||||
epd.Display_Base(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.init()
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(175, 105, 10, 10, 0xff)
|
||||
epd.text(str(i), 177, 106, 0x00)
|
||||
epd.displayPartial(epd.buffer)
|
||||
|
||||
print("sleep")
|
||||
epd.init()
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
epd.sleep()
|
||||
|
||||
|
||||
|
||||
epd = EPD_2in13_V4_Portrait()
|
||||
epd.Clear()
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 0, 10, 0x00)
|
||||
epd.text("ePaper-2.13_V4", 0, 30, 0x00)
|
||||
epd.text("Raspberry Pico", 0, 50, 0x00)
|
||||
epd.text("Hello World", 0, 70, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(10, 90, 60, 0x00)
|
||||
epd.vline(90, 90, 60, 0x00)
|
||||
epd.hline(10, 90, 80, 0x00)
|
||||
epd.hline(10, 150, 80, 0x00)
|
||||
epd.line(10, 90, 90, 150, 0x00)
|
||||
epd.line(90, 90, 10, 150, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(10, 180, 50, 40, 0x00)
|
||||
epd.fill_rect(60, 180, 50, 40, 0x00)
|
||||
epd.Display_Base(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.init()
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(40, 230, 40, 10, 0xff)
|
||||
epd.text(str(i), 60, 230, 0x00)
|
||||
epd.displayPartial(epd.buffer)
|
||||
|
||||
print("sleep")
|
||||
epd.init()
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
epd.sleep()
|
||||
247
Pico_ePaper_Code/python/Pico_ePaper-2.66-B.py
Normal file
247
Pico_ePaper_Code/python/Pico_ePaper-2.66-B.py
Normal file
@@ -0,0 +1,247 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.66-B.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-14
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 152
|
||||
EPD_HEIGHT = 296
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
WF_PARTIAL_2IN66 =[
|
||||
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,
|
||||
]
|
||||
|
||||
class EPD_2in9_B:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
self.lut = WF_PARTIAL_2IN66
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def SetWindow(self, x_start, y_start, x_end, y_end):
|
||||
self.send_command(0x44)
|
||||
self.send_data((x_start>>3) & 0x1f)
|
||||
self.send_data((x_end>>3) & 0x1f)
|
||||
|
||||
self.send_command(0x45)
|
||||
self.send_data(y_start&0xff)
|
||||
self.send_data((y_start&0x100)>>8)
|
||||
self.send_data((y_end&0xff))
|
||||
self.send_data((y_end&0x100)>>8)
|
||||
|
||||
def SetCursor(self, x_start, y_start):
|
||||
self.send_command(0x4E)
|
||||
self.send_data(x_start & 0x1f)
|
||||
|
||||
self.send_command(0x4f)
|
||||
self.send_data(y_start&0xff)
|
||||
self.send_data((y_start&0x100)>>8)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('e-Paper busy')
|
||||
utime.sleep_ms(50)
|
||||
while(self.busy_pin.value() == 1): # 0: idle, 1: busy
|
||||
utime.sleep_ms(10)
|
||||
print('e-Paper busy release')
|
||||
utime.sleep_ms(50)
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()#waiting for the electronic paper IC to release the idle signal
|
||||
|
||||
self.send_command(0x11)
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindow(0, 0, self.width-1, self.height-1)
|
||||
|
||||
self.send_command(0x21) #resolution setting
|
||||
self.send_data (0x00)
|
||||
self.send_data (0x80)
|
||||
|
||||
|
||||
self.SetCursor(0,0)
|
||||
self.ReadBusy()
|
||||
|
||||
|
||||
def display(self):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x24)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(~self.buffer_black[i + j * wide])
|
||||
|
||||
self.send_command(0x26)
|
||||
for j in range(0, high):
|
||||
for i in range(0, wide):
|
||||
self.send_data(~self.buffer_red[i + j * wide])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Clear(self, colorblack, colorred):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1([colorblack] * high * wide)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1([~colorred] * high * wide)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0X10) # deep sleep
|
||||
self.send_data(0x01)
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in9_B()
|
||||
epd.Clear(0xff, 0xff)
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0xff)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imagered.text("ePaper-2.66-B", 0, 25, 0x00)
|
||||
epd.imageblack.text("RPi Pico", 0, 40, 0x00)
|
||||
epd.imagered.text("Hello World", 0, 55, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imagered.vline(10, 90, 40, 0x00)
|
||||
epd.imagered.vline(90, 90, 40, 0x00)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imageblack.hline(10, 130, 80, 0x00)
|
||||
epd.imagered.line(10, 90, 90, 130, 0x00)
|
||||
epd.imageblack.line(90, 90, 10, 130, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageblack.rect(10, 150, 40, 40, 0x00)
|
||||
epd.imagered.fill_rect(60, 150, 40, 40, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
|
||||
epd.Clear(0xff, 0xff)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
276
Pico_ePaper_Code/python/Pico_ePaper-2.66.py
Normal file
276
Pico_ePaper_Code/python/Pico_ePaper-2.66.py
Normal file
@@ -0,0 +1,276 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.66.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-12
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 152
|
||||
EPD_HEIGHT = 296
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
|
||||
WF_PARTIAL_2IN66 =[
|
||||
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,
|
||||
]
|
||||
|
||||
class EPD_2in66:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
self.lut = WF_PARTIAL_2IN66
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_Landscape = bytearray(self.height * self.width // 8)
|
||||
self.buffer_Portrait = bytearray(self.height * self.width // 8)
|
||||
|
||||
self.image_Landscape = framebuf.FrameBuffer(self.buffer_Landscape, self.height, self.width, framebuf.MONO_VLSB)
|
||||
self.image_Portrait = framebuf.FrameBuffer(self.buffer_Portrait, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init(0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.reset_pin(1)
|
||||
utime.sleep_ms(200)
|
||||
self.reset_pin(0)
|
||||
utime.sleep_ms(200)
|
||||
self.reset_pin(1)
|
||||
utime.sleep_ms(200)
|
||||
|
||||
def send_command(self, command):
|
||||
self.cs_pin(1)
|
||||
self.dc_pin(0)
|
||||
self.cs_pin(0)
|
||||
self.spi.write(bytearray([command]))
|
||||
self.cs_pin(1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.cs_pin(1)
|
||||
self.dc_pin(1)
|
||||
self.cs_pin(0)
|
||||
self.spi.write(bytearray([data]))
|
||||
self.cs_pin(1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.cs_pin(1)
|
||||
self.dc_pin(1)
|
||||
self.cs_pin(0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.cs_pin(1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('e-Paper busy')
|
||||
utime.sleep_ms(100)
|
||||
while(self.busy_pin.value() == 1): # 0: idle, 1: busy
|
||||
utime.sleep_ms(100)
|
||||
print('e-Paper busy release')
|
||||
utime.sleep_ms(100)
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
def SendLut(self):
|
||||
self.send_command(0x32)
|
||||
for i in range(0, 153):
|
||||
self.send_data(self.lut[i])
|
||||
self.ReadBusy()
|
||||
|
||||
def SetWindow(self, x_start, y_start, x_end, y_end):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
# x point must be the multiple of 8 or the last 3 bits will be ignored
|
||||
self.send_data((x_start>>3) & 0xFF)
|
||||
self.send_data((x_end>>3) & 0xFF)
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(y_start & 0xFF)
|
||||
self.send_data((y_start >> 8) & 0xFF)
|
||||
self.send_data(y_end & 0xFF)
|
||||
self.send_data((y_end >> 8) & 0xFF)
|
||||
|
||||
def SetCursor(self, x, y):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(x & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(y & 0xFF)
|
||||
self.send_data((y >> 8) & 0xFF)
|
||||
|
||||
def init(self, mode):
|
||||
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x11)
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindow(8, 0, self.width, self.height)
|
||||
|
||||
if(mode == 0):
|
||||
self.send_command(0x3c)
|
||||
self.send_data(0x01)
|
||||
elif(mode == 1):
|
||||
self.SendLut()
|
||||
self.send_command(0x37) # set display option, these setting turn on previous function
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x40)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xcf)
|
||||
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
else:
|
||||
print("There is no such mode")
|
||||
|
||||
def display(self, image):
|
||||
if (image == None):
|
||||
return
|
||||
|
||||
self.SetCursor(1, 295)
|
||||
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Landscape(self, image):
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
|
||||
self.SetCursor(1, 295)
|
||||
|
||||
self.send_command(0x24)
|
||||
for j in range(Height):
|
||||
for i in range(Width):
|
||||
self.send_data(image[(Width-i-1) * Height + j])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def Clear(self, color):
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1([color] * self.height * int(self.width / 8))
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x10) # DEEP_SLEEP_MODE
|
||||
self.send_data(0x01)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in66()
|
||||
# epd.Clear(0xff)
|
||||
#
|
||||
# epd.image_Portrait.fill(0xff)
|
||||
# epd.image_Portrait.text("Waveshare", 13, 10, 0x00)
|
||||
# epd.image_Portrait.text("Pico_ePaper-2.66", 13, 40, 0x00)
|
||||
# epd.image_Portrait.text("Raspberry Pico", 13, 70, 0x00)
|
||||
# epd.display(epd.buffer_Portrait)
|
||||
# utime.sleep_ms(2000)
|
||||
#
|
||||
# epd.image_Portrait.vline(10, 90, 60, 0x00)
|
||||
# epd.image_Portrait.vline(140, 90, 60, 0x00)
|
||||
# epd.image_Portrait.hline(10, 90, 130, 0x00)
|
||||
# epd.image_Portrait.hline(10, 150, 130, 0x00)
|
||||
# epd.image_Portrait.line(10, 90, 140, 150, 0x00)
|
||||
# epd.image_Portrait.line(140, 90, 10, 150, 0x00)
|
||||
# epd.display(epd.buffer_Portrait)
|
||||
# utime.sleep_ms(2000)
|
||||
#
|
||||
# epd.image_Portrait.rect(10, 180, 60, 80, 0x00)
|
||||
# epd.image_Portrait.fill_rect(80, 180, 60, 80, 0x00)
|
||||
# epd.display(epd.buffer_Portrait)
|
||||
# utime.sleep_ms(2000)
|
||||
#
|
||||
# epd.init(1)
|
||||
# for i in range(0, 10):
|
||||
# epd.image_Portrait.fill_rect(52, 270, 40, 20, 0xff)
|
||||
# epd.image_Portrait.text(str(i), 72, 270, 0x00)
|
||||
# epd.display(epd.buffer_Portrait)
|
||||
#
|
||||
# epd.Clear(0xff)
|
||||
epd.image_Landscape.fill(0xff)
|
||||
epd.image_Landscape.text("Waveshare", 13, 10, 0x00)
|
||||
epd.image_Landscape.text("Pico_ePaper-2.66", 13, 40, 0x00)
|
||||
epd.image_Landscape.text("Raspberry Pico", 13, 70, 0x00)
|
||||
epd.display_Landscape(epd.buffer_Landscape)
|
||||
utime.sleep_ms(2000)
|
||||
|
||||
epd.init(0)
|
||||
epd.Clear(0xff)
|
||||
utime.sleep_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
|
||||
|
||||
|
||||
196
Pico_ePaper_Code/python/Pico_ePaper-2.9-B.py
Normal file
196
Pico_ePaper_Code/python/Pico_ePaper-2.9-B.py
Normal file
@@ -0,0 +1,196 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.9-B.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-03-16
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 128
|
||||
EPD_HEIGHT = 296
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_2in9_B:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
self.send_command(0x71)
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
self.send_command(0x04)
|
||||
self.ReadBusy()#waiting for the electronic paper IC to release the idle signal
|
||||
|
||||
self.send_command(0x00) #panel setting
|
||||
self.send_data(0x0f) #LUT from OTP,128x296
|
||||
self.send_data(0x89) #Temperature sensor, boost and other related timing settings
|
||||
|
||||
self.send_command(0x61) #resolution setting
|
||||
self.send_data (0x80)
|
||||
self.send_data (0x01)
|
||||
self.send_data (0x28)
|
||||
|
||||
self.send_command(0X50) #VCOM AND DATA INTERVAL SETTING
|
||||
self.send_data(0x77) #WBmode:VBDF 17|D7 VBDW 97 VBDB 57
|
||||
# WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7
|
||||
return 0
|
||||
|
||||
def display(self):
|
||||
self.send_command(0x10)
|
||||
self.send_data1(self.buffer_black)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1(self.buffer_red)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Clear(self, colorblack, colorred):
|
||||
self.send_command(0x10)
|
||||
self.send_data1([colorblack] * self.height * int(self.width / 8))
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0X02) # power off
|
||||
self.ReadBusy()
|
||||
self.send_command(0X07) # deep sleep
|
||||
self.send_data(0xA5)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in9_B()
|
||||
epd.Clear(0xff, 0xff)
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0xff)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imagered.text("ePaper-2.9-B", 0, 25, 0x00)
|
||||
epd.imageblack.text("RPi Pico", 0, 40, 0x00)
|
||||
epd.imagered.text("Hello World", 0, 55, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imagered.vline(10, 90, 40, 0x00)
|
||||
epd.imagered.vline(90, 90, 40, 0x00)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imageblack.hline(10, 130, 80, 0x00)
|
||||
epd.imagered.line(10, 90, 90, 130, 0x00)
|
||||
epd.imageblack.line(90, 90, 10, 130, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageblack.rect(10, 150, 40, 40, 0x00)
|
||||
epd.imagered.fill_rect(60, 150, 40, 40, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.Clear(0xff, 0xff)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
348
Pico_ePaper_Code/python/Pico_ePaper-2.9-B_V4.py
Normal file
348
Pico_ePaper_Code/python/Pico_ePaper-2.9-B_V4.py
Normal file
@@ -0,0 +1,348 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.13-B_V4.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2022-08-22
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
|
||||
EPD_WIDTH = 128
|
||||
EPD_HEIGHT = 296
|
||||
|
||||
SCK_PIN = 10
|
||||
DIN_PIN = 11
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_2in9_B_V4_Portrait:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
if EPD_WIDTH % 8 == 0:
|
||||
self.width = EPD_WIDTH
|
||||
else :
|
||||
self.width = (EPD_WIDTH // 8) * 8 + 8
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1,baudrate=4000_000,sck=Pin(SCK_PIN),mosi=Pin(DIN_PIN))
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer_balck = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_balck, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
while(self.digital_read(self.busy_pin) == 1):
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
self.delay_ms(20)
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xF7)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Base(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xF4)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Fast(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Partial(self):
|
||||
self.send_command(0x22) #Display Update Control
|
||||
self.send_data(0x1C)
|
||||
self.send_command(0x20) #Activate Display Update Sequence
|
||||
self.ReadBusy()
|
||||
|
||||
|
||||
def init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data((self.height-1)%256)
|
||||
self.send_data((self.height-1)//256)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x44) #set Ram-X address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(self.width//8-1)
|
||||
|
||||
self.send_command(0x45) #set Ram-Y address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data((self.height-1)%256)
|
||||
self.send_data((self.height-1)//256)
|
||||
|
||||
self.send_command(0x3C) #BorderWavefrom
|
||||
self.send_data(0x05)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x18) #Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x4E) # set RAM x address count to 0
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F) # set RAM y address count to 0X199
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
|
||||
return 0
|
||||
|
||||
def init_Fast(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x18) #Read built-in temperature sensor
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0xB1)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x1A) # Write to temperature register
|
||||
self.send_data(0x5a) # 90
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x22) # Load temperature value
|
||||
self.send_data(0x91)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data((self.height-1)%256)
|
||||
self.send_data((self.height-1)//256)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.send_command(0x44) #set Ram-X address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(self.width//8-1)
|
||||
|
||||
self.send_command(0x45) #set Ram-Y address start/end position
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data((self.height-1)%256)
|
||||
self.send_data((self.height-1)//256)
|
||||
|
||||
self.send_command(0x4E) # set RAM x address count to 0
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x4F) # set RAM y address count to 0X199
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.ReadBusy()
|
||||
|
||||
return 0
|
||||
|
||||
def display(self): # ryimage: red or yellow image
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.buffer_balck)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(self.buffer_red)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Fast(self): # ryimage: red or yellow image
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.buffer_balck)
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1(self.buffer_red)
|
||||
|
||||
self.TurnOnDisplay_Fast()
|
||||
|
||||
def Clear(self):
|
||||
self.send_command(0x24)
|
||||
self.send_data1([0xFF] * self.height * int(self.width / 8))
|
||||
|
||||
self.send_command(0x26)
|
||||
self.send_data1([0x00] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Partial(self, Image, Xstart, Ystart, Xend, Yend):
|
||||
if((Xstart % 8 + Xend % 8 == 8 & Xstart % 8 > Xend % 8) | Xstart % 8 + Xend % 8 == 0 | (Xend - Xstart)%8 == 0):
|
||||
Xstart = Xstart // 8
|
||||
Xend = Xend // 8
|
||||
else:
|
||||
Xstart = Xstart // 8
|
||||
if Xend % 8 == 0:
|
||||
Xend = Xend // 8
|
||||
else:
|
||||
Xend = Xend // 8 + 1
|
||||
|
||||
if(self.width % 8 == 0):
|
||||
Width = self.width // 8
|
||||
else:
|
||||
Width = self.width // 8 +1
|
||||
Height = self.height
|
||||
|
||||
Xend -= 1
|
||||
Yend -= 1
|
||||
|
||||
self.send_command(0x44) # set RAM x address start/end, in page 35
|
||||
self.send_data(Xstart & 0xff) # RAM x address start at 00h
|
||||
self.send_data(Xend & 0xff) # RAM x address end at 0fh(15+1)*8->128
|
||||
self.send_command(0x45) # set RAM y address start/end, in page 35
|
||||
self.send_data(Ystart & 0xff) # RAM y address start at 0127h
|
||||
self.send_data((Ystart>>8) & 0x01) # RAM y address start at 0127h
|
||||
self.send_data(Yend & 0xff) # RAM y address end at 00h
|
||||
self.send_data((Yend>>8) & 0x01)
|
||||
|
||||
self.send_command(0x4E) # set RAM x address count to 0
|
||||
self.send_data(Xstart & 0xff)
|
||||
self.send_command(0x4F) # set RAM y address count to 0X127
|
||||
self.send_data(Ystart & 0xff)
|
||||
self.send_data((Ystart>>8) & 0x01)
|
||||
|
||||
self.send_command(0x24) #Write Black and White image to RAM
|
||||
for j in range(Height):
|
||||
for i in range(Width):
|
||||
if((j > Ystart-1) & (j < (Yend + 1)) & (i > Xstart-1) & (i < (Xend + 1))):
|
||||
self.send_data(Image[i + j * Width])
|
||||
self.TurnOnDisplay_Partial()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x10)
|
||||
self.send_data(0x01)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in9_B_V4_Portrait()
|
||||
epd.Clear()
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0x00)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imagered.text("ePaper-2.9-B-V4", 0, 25, 0xff)
|
||||
epd.imageblack.text("RPi Pico", 0, 40, 0x00)
|
||||
epd.imagered.text("Hello World", 0, 55, 0xff)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imagered.vline(10, 90, 40, 0xff)
|
||||
epd.imagered.vline(90, 90, 40, 0xff)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imageblack.hline(10, 130, 80, 0x00)
|
||||
epd.imagered.line(10, 90, 90, 130, 0xff)
|
||||
epd.imageblack.line(90, 90, 10, 130, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.init_Fast
|
||||
epd.imageblack.rect(10, 150, 40, 40, 0x00)
|
||||
epd.imagered.fill_rect(60, 150, 40, 40, 0xff)
|
||||
epd.display_Fast()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.init()
|
||||
epd.Clear()
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
195
Pico_ePaper_Code/python/Pico_ePaper-2.9-C.py
Normal file
195
Pico_ePaper_Code/python/Pico_ePaper-2.9-C.py
Normal file
@@ -0,0 +1,195 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.9-C.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-03-16
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 128
|
||||
EPD_HEIGHT = 296
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
class EPD_2in9_C:
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer_black = bytearray(self.height * self.width // 8)
|
||||
self.buffer_red = bytearray(self.height * self.width // 8)
|
||||
self.imageblack = framebuf.FrameBuffer(self.buffer_black, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.imagered = framebuf.FrameBuffer(self.buffer_red, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('busy')
|
||||
self.send_command(0x71)
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(10)
|
||||
print('busy release')
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
self.send_command(0x06) # boost
|
||||
self.send_data (0x17)
|
||||
self.send_data (0x17)
|
||||
self.send_data (0x17)
|
||||
self.send_command(0x04) # POWER_ON
|
||||
self.ReadBusy()
|
||||
self.send_command(0X00) # PANEL_SETTING
|
||||
self.send_data(0x8F)
|
||||
self.send_command(0X50) # VCOM_AND_DATA_INTERVAL_SETTING
|
||||
self.send_data(0x77)
|
||||
self.send_command(0x61) # TCON_RESOLUTION
|
||||
self.send_data (0x80)
|
||||
self.send_data (0x01)
|
||||
self.send_data (0x28)
|
||||
return 0
|
||||
|
||||
def display(self):
|
||||
self.send_command(0x10)
|
||||
self.send_data1(self.buffer_black)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1(self.buffer_red)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
def Clear(self, colorblack, colorred):
|
||||
self.send_command(0x10)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1([colorred] * self.height * int(self.width / 8))
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0X02) # power off
|
||||
self.ReadBusy()
|
||||
self.send_command(0X07) # deep sleep
|
||||
self.send_data(0xA5)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2in9_C()
|
||||
epd.Clear(0xff, 0xff)
|
||||
|
||||
epd.imageblack.fill(0xff)
|
||||
epd.imagered.fill(0xff)
|
||||
epd.imageblack.text("Waveshare", 0, 10, 0x00)
|
||||
epd.imagered.text("ePaper-2.9-C", 0, 25, 0x00)
|
||||
epd.imageblack.text("RPi Pico", 0, 40, 0x00)
|
||||
epd.imagered.text("Hello World", 0, 55, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imagered.vline(10, 90, 40, 0x00)
|
||||
epd.imagered.vline(90, 90, 40, 0x00)
|
||||
epd.imageblack.hline(10, 90, 80, 0x00)
|
||||
epd.imageblack.hline(10, 130, 80, 0x00)
|
||||
epd.imagered.line(10, 90, 90, 130, 0x00)
|
||||
epd.imageblack.line(90, 90, 10, 130, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.imageblack.rect(10, 150, 40, 40, 0x00)
|
||||
epd.imagered.fill_rect(60, 150, 40, 40, 0x00)
|
||||
epd.display()
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.Clear(0xff, 0xff)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
731
Pico_ePaper_Code/python/Pico_ePaper-2.9.py
Normal file
731
Pico_ePaper_Code/python/Pico_ePaper-2.9.py
Normal file
@@ -0,0 +1,731 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.9.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-03-16
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
# Display resolution
|
||||
EPD_WIDTH = 128
|
||||
EPD_HEIGHT = 296
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
WF_PARTIAL_2IN9 = [
|
||||
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,0x1,
|
||||
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,
|
||||
]
|
||||
|
||||
WS_20_30 = [
|
||||
0x80, 0x66, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0,
|
||||
0x10, 0x66, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0,
|
||||
0x80, 0x66, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0,
|
||||
0x10, 0x66, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0,
|
||||
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
|
||||
0x14, 0x8, 0x0, 0x0, 0x0, 0x0, 0x2,
|
||||
0xA, 0xA, 0x0, 0xA, 0xA, 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,
|
||||
0x14, 0x8, 0x0, 0x1, 0x0, 0x0, 0x1,
|
||||
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1,
|
||||
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
|
||||
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
|
||||
0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x0, 0x0, 0x0,
|
||||
0x22, 0x17, 0x41, 0x0, 0x32, 0x36
|
||||
]
|
||||
|
||||
Gray4 = [
|
||||
0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x20, 0x60, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x28, 0x60, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x2A, 0x60, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x02, 0x00, 0x05, 0x14, 0x00, 0x00,
|
||||
0x1E, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x01,
|
||||
0x00, 0x02, 0x00, 0x05, 0x14, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x24, 0x22, 0x22, 0x22, 0x23, 0x32, 0x00, 0x00, 0x00,
|
||||
0x22, 0x17, 0x41, 0xAE, 0x32, 0x28
|
||||
]
|
||||
|
||||
class EPD_2in9_Portrait(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.black = 0x00
|
||||
self.white = 0xff
|
||||
self.darkgray = 0xaa
|
||||
self.grayish = 0x55
|
||||
|
||||
self.partial_lut = WF_PARTIAL_2IN9
|
||||
self.full_lut = WS_20_30
|
||||
self.Gray4_lut = Gray4
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
self.buffer_4Gray = bytearray(self.height * self.width // 4)
|
||||
self.image4Gray = framebuf.FrameBuffer(self.buffer_4Gray, self.width, self.height, framebuf.GS2_HMSB)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 1): # 0: idle, 1: busy
|
||||
self.delay_ms(10)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) # DISPLAY_UPDATE_CONTROL_2
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20) # MASTER_ACTIVATION
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Partial(self):
|
||||
self.send_command(0x22) # DISPLAY_UPDATE_CONTROL_2
|
||||
self.send_data(0x0F)
|
||||
self.send_command(0x20) # MASTER_ACTIVATION
|
||||
self.ReadBusy()
|
||||
|
||||
def lut(self, lut):
|
||||
self.send_command(0x32)
|
||||
self.send_data1(lut[0:153])
|
||||
self.ReadBusy()
|
||||
|
||||
def SetLut(self, lut):
|
||||
self.lut(lut)
|
||||
self.send_command(0x3f)
|
||||
self.send_data(lut[153])
|
||||
self.send_command(0x03) # gate voltage
|
||||
self.send_data(lut[154])
|
||||
self.send_command(0x04) # source voltage
|
||||
self.send_data(lut[155]) # VSH
|
||||
self.send_data(lut[156]) # VSH2
|
||||
self.send_data(lut[157]) # VSL
|
||||
self.send_command(0x2c) # VCOM
|
||||
self.send_data(lut[158])
|
||||
|
||||
def SetWindow(self, x_start, y_start, x_end, y_end):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
# x point must be the multiple of 8 or the last 3 bits will be ignored
|
||||
self.send_data((x_start>>3) & 0xFF)
|
||||
self.send_data((x_end>>3) & 0xFF)
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(y_start & 0xFF)
|
||||
self.send_data((y_start >> 8) & 0xFF)
|
||||
self.send_data(y_end & 0xFF)
|
||||
self.send_data((y_end >> 8) & 0xFF)
|
||||
|
||||
def SetCursor(self, x, y):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(x & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(y & 0xFF)
|
||||
self.send_data((y >> 8) & 0xFF)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data(0x27)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindow(0, 0, self.width-1, self.height-1)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.SetCursor(0, 0)
|
||||
self.ReadBusy()
|
||||
|
||||
self.SetLut(self.full_lut)
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
def init_4Gray(self):
|
||||
self.reset()
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data(0x27)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x03)
|
||||
|
||||
self.SetWindow(8, 0, self.width, self.height-1)
|
||||
|
||||
self.send_command(0x3C)
|
||||
self.send_data(0x04)
|
||||
|
||||
self.SetCursor(1, 0)
|
||||
self.ReadBusy()
|
||||
|
||||
self.SetLut(self.Gray4_lut)
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
def display(self, image):
|
||||
if (image == None):
|
||||
return
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Base(self, image):
|
||||
if (image == None):
|
||||
return
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1(image)
|
||||
|
||||
self.send_command(0x26) # WRITE_RAM
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_4Gray(self, image):
|
||||
self.send_command(0x24)
|
||||
for i in range(0, 4736):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x00 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x01 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x00
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x01
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x00 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x01 # gray2
|
||||
|
||||
if (( j!=1 ) | ( k!=1 )):
|
||||
temp3 <<= 1
|
||||
temp1 >>= 2
|
||||
self.send_data(temp3)
|
||||
|
||||
self.send_command(0x26)
|
||||
for i in range(0, 4736):
|
||||
temp3=0
|
||||
for j in range(0, 2):
|
||||
temp1 = image[i*2+j]
|
||||
for k in range(0, 2):
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03):
|
||||
temp3 |= 0x00 # white
|
||||
elif(temp2 == 0x00):
|
||||
temp3 |= 0x01 # black
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
temp3 <<= 1
|
||||
|
||||
temp1 >>= 2
|
||||
temp2 = temp1&0x03
|
||||
if(temp2 == 0x03): # white
|
||||
temp3 |= 0x00
|
||||
elif(temp2 == 0x00): # black
|
||||
temp3 |= 0x01
|
||||
elif(temp2 == 0x02):
|
||||
temp3 |= 0x01 # gray1
|
||||
else: # 0x01
|
||||
temp3 |= 0x00 # gray2
|
||||
if(j!=1 or k!=1):
|
||||
temp3 <<= 1
|
||||
temp1 >>= 2
|
||||
self.send_data(temp3)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Partial(self, image):
|
||||
if (image == None):
|
||||
return
|
||||
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(2)
|
||||
|
||||
self.SetLut(self.partial_lut)
|
||||
self.send_command(0x37)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x40)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C) #BorderWaveform
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xC0)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.SetWindow(0, 0, self.width - 1, self.height - 1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1(image)
|
||||
self.TurnOnDisplay_Partial()
|
||||
|
||||
def Clear(self, color):
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1([color] * self.height * int(self.width / 8))
|
||||
self.send_command(0x26) # WRITE_RAM
|
||||
self.send_data1([color] * self.height * int(self.width / 8))
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x10) # DEEP_SLEEP_MODE
|
||||
self.send_data(0x01)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
|
||||
class EPD_2in9_Landscape(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
|
||||
self.partial_lut = WF_PARTIAL_2IN9
|
||||
self.full_lut = WS_20_30
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.height, self.width, framebuf.MONO_VLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep(delaytime / 1000.0)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(50)
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print("e-Paper busy")
|
||||
while(self.digital_read(self.busy_pin) == 1): # 0: idle, 1: busy
|
||||
self.delay_ms(10)
|
||||
print("e-Paper busy release")
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x22) # DISPLAY_UPDATE_CONTROL_2
|
||||
self.send_data(0xC7)
|
||||
self.send_command(0x20) # MASTER_ACTIVATION
|
||||
self.ReadBusy()
|
||||
|
||||
def TurnOnDisplay_Partial(self):
|
||||
self.send_command(0x22) # DISPLAY_UPDATE_CONTROL_2
|
||||
self.send_data(0x0F)
|
||||
self.send_command(0x20) # MASTER_ACTIVATION
|
||||
self.ReadBusy()
|
||||
|
||||
def lut(self, lut):
|
||||
self.send_command(0x32)
|
||||
self.send_data1(lut[0:153])
|
||||
self.ReadBusy()
|
||||
|
||||
def SetLut(self, lut):
|
||||
self.lut(lut)
|
||||
self.send_command(0x3f)
|
||||
self.send_data(lut[153])
|
||||
self.send_command(0x03) # gate voltage
|
||||
self.send_data(lut[154])
|
||||
self.send_command(0x04) # source voltage
|
||||
self.send_data(lut[155]) # VSH
|
||||
self.send_data(lut[156]) # VSH2
|
||||
self.send_data(lut[157]) # VSL
|
||||
self.send_command(0x2c) # VCOM
|
||||
self.send_data(lut[158])
|
||||
|
||||
def SetWindow(self, x_start, y_start, x_end, y_end):
|
||||
self.send_command(0x44) # SET_RAM_X_ADDRESS_START_END_POSITION
|
||||
# x point must be the multiple of 8 or the last 3 bits will be ignored
|
||||
self.send_data((x_start>>3) & 0xFF)
|
||||
self.send_data((x_end>>3) & 0xFF)
|
||||
self.send_command(0x45) # SET_RAM_Y_ADDRESS_START_END_POSITION
|
||||
self.send_data(y_start & 0xFF)
|
||||
self.send_data((y_start >> 8) & 0xFF)
|
||||
self.send_data(y_end & 0xFF)
|
||||
self.send_data((y_end >> 8) & 0xFF)
|
||||
|
||||
def SetCursor(self, x, y):
|
||||
self.send_command(0x4E) # SET_RAM_X_ADDRESS_COUNTER
|
||||
self.send_data(x & 0xFF)
|
||||
|
||||
self.send_command(0x4F) # SET_RAM_Y_ADDRESS_COUNTER
|
||||
self.send_data(y & 0xFF)
|
||||
self.send_data((y >> 8) & 0xFF)
|
||||
self.ReadBusy()
|
||||
|
||||
def init(self):
|
||||
# EPD hardware init start
|
||||
self.reset()
|
||||
|
||||
self.ReadBusy()
|
||||
self.send_command(0x12) #SWRESET
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x01) #Driver output control
|
||||
self.send_data(0x27)
|
||||
self.send_data(0x01)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x11) #data entry mode
|
||||
self.send_data(0x07)
|
||||
|
||||
self.SetWindow(0, 0, self.width-1, self.height-1)
|
||||
|
||||
self.send_command(0x21) # Display update control
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x80)
|
||||
|
||||
self.SetCursor(0, 0)
|
||||
self.ReadBusy()
|
||||
|
||||
self.SetLut(self.full_lut)
|
||||
# EPD hardware init end
|
||||
return 0
|
||||
|
||||
def display(self, image):
|
||||
if (image == None):
|
||||
return
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Base(self, image):
|
||||
if (image == None):
|
||||
return
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
|
||||
self.send_command(0x26) # WRITE_RAM
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Partial(self, image):
|
||||
if (image == None):
|
||||
return
|
||||
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(2)
|
||||
|
||||
self.SetLut(self.partial_lut)
|
||||
self.send_command(0x37)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x40)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x00)
|
||||
|
||||
self.send_command(0x3C) #BorderWaveform
|
||||
self.send_data(0x80)
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data(0xC0)
|
||||
self.send_command(0x20)
|
||||
self.ReadBusy()
|
||||
|
||||
self.SetWindow(0, 0, self.width - 1, self.height - 1)
|
||||
self.SetCursor(0, 0)
|
||||
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
for j in range(int(self.width / 8) - 1, -1, -1):
|
||||
for i in range(0, self.height):
|
||||
self.send_data(image[i + j * self.height])
|
||||
self.TurnOnDisplay_Partial()
|
||||
|
||||
def Clear(self, color):
|
||||
self.send_command(0x24) # WRITE_RAM
|
||||
self.send_data1([color] * self.height * int(self.width / 8))
|
||||
self.send_command(0x26) # WRITE_RAM
|
||||
self.send_data1([color] * self.height * int(self.width / 8))
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x10) # DEEP_SLEEP_MODE
|
||||
self.send_data(0x01)
|
||||
|
||||
self.delay_ms(2000)
|
||||
self.module_exit()
|
||||
|
||||
if __name__=='__main__':
|
||||
# Landscape
|
||||
epd = EPD_2in9_Landscape()
|
||||
epd.Clear(0xff)
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 5, 10, 0x00)
|
||||
epd.text("Pico_ePaper-2.9", 5, 20, 0x00)
|
||||
epd.text("Raspberry Pico", 5, 30, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(10, 40, 60, 0x00)
|
||||
epd.vline(120, 40, 60, 0x00)
|
||||
epd.hline(10, 40, 110, 0x00)
|
||||
epd.hline(10, 100, 110, 0x00)
|
||||
epd.line(10, 40, 120, 100, 0x00)
|
||||
epd.line(120, 40, 10, 100, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(150, 5, 50, 55, 0x00)
|
||||
epd.fill_rect(150, 65, 50, 115, 0x00)
|
||||
epd.display_Base(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(220, 60, 10, 10, 0xff)
|
||||
epd.text(str(i), 222, 62, 0x00)
|
||||
epd.display_Partial(epd.buffer)
|
||||
|
||||
# Portrait
|
||||
epd = EPD_2in9_Portrait()
|
||||
epd.Clear(0xff)
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 5, 10, 0x00)
|
||||
epd.text("Pico_ePaper-2.9", 5, 40, 0x00)
|
||||
epd.text("Raspberry Pico", 5, 70, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(10, 90, 60, 0x00)
|
||||
epd.vline(120, 90, 60, 0x00)
|
||||
epd.hline(10, 90, 110, 0x00)
|
||||
epd.hline(10, 150, 110, 0x00)
|
||||
epd.line(10, 90, 120, 150, 0x00)
|
||||
epd.line(120, 90, 10, 150, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(10, 180, 50, 80, 0x00)
|
||||
epd.fill_rect(70, 180, 50, 80, 0x00)
|
||||
epd.display_Base(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(40, 270, 40, 10, 0xff)
|
||||
epd.text(str(i), 60, 270, 0x00)
|
||||
epd.display_Partial(epd.buffer)
|
||||
|
||||
epd.init_4Gray()
|
||||
epd.image4Gray.fill_rect(0, 0, 127, 74, epd.black)
|
||||
epd.image4Gray.text('GRAY1',10, 33, epd.white)
|
||||
epd.image4Gray.fill_rect(0, 74, 127, 74, epd.darkgray)
|
||||
epd.image4Gray.text('GRAY2',10, 107, epd.grayish)
|
||||
epd.image4Gray.fill_rect(0, 148, 127, 74, epd.grayish)
|
||||
epd.image4Gray.text('GRAY3',10, 181, epd.darkgray)
|
||||
epd.image4Gray.fill_rect(0, 222, 127, 74, epd.white)
|
||||
epd.image4Gray.text('GRAY4',10, 255, epd.black)
|
||||
epd.display_4Gray(epd.buffer_4Gray)
|
||||
epd.delay_ms(5000)
|
||||
|
||||
epd.init()
|
||||
epd.Clear(0xff)
|
||||
epd.delay_ms(2000)
|
||||
print("sleep")
|
||||
epd.sleep()
|
||||
405
Pico_ePaper_Code/python/Pico_ePaper-2.9_D.py
Normal file
405
Pico_ePaper_Code/python/Pico_ePaper-2.9_D.py
Normal file
@@ -0,0 +1,405 @@
|
||||
# *****************************************************************************
|
||||
# * | File : Pico_ePaper-2.9-D.py
|
||||
# * | Author : Waveshare team
|
||||
# * | Function : Electronic paper driver
|
||||
# * | Info :
|
||||
# *----------------
|
||||
# * | This version: V1.0
|
||||
# * | Date : 2021-05-14
|
||||
# # | Info : python demo
|
||||
# -----------------------------------------------------------------------------
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documnetation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
|
||||
from machine import Pin, SPI
|
||||
import framebuf
|
||||
import utime
|
||||
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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
|
||||
'''
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
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,
|
||||
]
|
||||
|
||||
EPD_WIDTH = 128
|
||||
EPD_HEIGHT = 296
|
||||
|
||||
RST_PIN = 12
|
||||
DC_PIN = 8
|
||||
CS_PIN = 9
|
||||
BUSY_PIN = 13
|
||||
|
||||
FULL_UPDATE = 0
|
||||
PART_UPDATE = 1
|
||||
|
||||
class EPD_2IN9_D(framebuf.FrameBuffer):
|
||||
def __init__(self):
|
||||
self.reset_pin = Pin(RST_PIN, Pin.OUT)
|
||||
|
||||
self.busy_pin = Pin(BUSY_PIN, Pin.IN, Pin.PULL_UP)
|
||||
self.cs_pin = Pin(CS_PIN, Pin.OUT)
|
||||
self.width = EPD_WIDTH
|
||||
self.height = EPD_HEIGHT
|
||||
|
||||
self.lut_vcomDC = EPD_2IN9D_lut_vcomDC
|
||||
self.lut_ww = EPD_2IN9D_lut_ww
|
||||
self.lut_bw = EPD_2IN9D_lut_bw
|
||||
self.lut_wb = EPD_2IN9D_lut_wb
|
||||
self.lut_bb = EPD_2IN9D_lut_bb
|
||||
|
||||
self.lut_vcom1 = EPD_2IN9D_lut_vcom1
|
||||
self.lut_ww1 = EPD_2IN9D_lut_ww1
|
||||
self.lut_bw1 = EPD_2IN9D_lut_bw1
|
||||
self.lut_wb1 = EPD_2IN9D_lut_wb1
|
||||
self.lut_bb1 = EPD_2IN9D_lut_bb1
|
||||
|
||||
self.spi = SPI(1)
|
||||
self.spi.init(baudrate=4000_000)
|
||||
self.dc_pin = Pin(DC_PIN, Pin.OUT)
|
||||
|
||||
|
||||
self.buffer = bytearray(self.height * self.width // 8)
|
||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_HLSB)
|
||||
self.init()
|
||||
|
||||
def digital_write(self, pin, value):
|
||||
pin.value(value)
|
||||
|
||||
def digital_read(self, pin):
|
||||
return pin.value()
|
||||
|
||||
def delay_ms(self, delaytime):
|
||||
utime.sleep_ms(delaytime)
|
||||
|
||||
def spi_writebyte(self, data):
|
||||
self.spi.write(bytearray(data))
|
||||
|
||||
def module_exit(self):
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
|
||||
# Hardware reset
|
||||
def reset(self):
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
self.digital_write(self.reset_pin, 0)
|
||||
self.delay_ms(2)
|
||||
self.digital_write(self.reset_pin, 1)
|
||||
self.delay_ms(200)
|
||||
|
||||
|
||||
def send_command(self, command):
|
||||
self.digital_write(self.dc_pin, 0)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([command])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data(self, data):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi_writebyte([data])
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def send_data1(self, buf):
|
||||
self.digital_write(self.dc_pin, 1)
|
||||
self.digital_write(self.cs_pin, 0)
|
||||
self.spi.write(bytearray(buf))
|
||||
self.digital_write(self.cs_pin, 1)
|
||||
|
||||
def ReadBusy(self):
|
||||
print('e-Paper busy')
|
||||
busy = 1
|
||||
self.send_command(0x71)
|
||||
while(self.digital_read(self.busy_pin) == 0):
|
||||
self.send_command(0x71)
|
||||
self.delay_ms(200)
|
||||
print('e-Paper busy release')
|
||||
|
||||
def SetFullReg(self):
|
||||
self.send_command(0x50)
|
||||
self.send_data(0xB7)
|
||||
|
||||
self.send_command(0x20)
|
||||
self.send_data1(self.lut_vcomDC[0:44])
|
||||
|
||||
self.send_command(0x21)
|
||||
self.send_data1(self.lut_ww[0:42])
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data1(self.lut_bw[0:42])
|
||||
|
||||
self.send_command(0x23)
|
||||
self.send_data1(self.lut_bb[0:42])
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.lut_wb[0:42])
|
||||
|
||||
|
||||
def SetPartReg(self):
|
||||
self.send_command(0x82)
|
||||
self.send_data(0x00)
|
||||
self.send_command(0x50)
|
||||
self.send_data(0xB7)
|
||||
|
||||
self.send_command(0x20)
|
||||
self.send_data1(self.lut_vcom1[0:44])
|
||||
|
||||
self.send_command(0x21)
|
||||
self.send_data1(self.lut_ww1[0:42])
|
||||
|
||||
self.send_command(0x22)
|
||||
self.send_data1(self.lut_bw1[0:42])
|
||||
|
||||
self.send_command(0x23)
|
||||
self.send_data1(self.lut_wb1[0:42])
|
||||
|
||||
self.send_command(0x24)
|
||||
self.send_data1(self.lut_bb1[0:42])
|
||||
|
||||
|
||||
def TurnOnDisplay(self):
|
||||
self.send_command(0x12)
|
||||
self.delay_ms(100)
|
||||
self.ReadBusy()
|
||||
|
||||
|
||||
def init(self):
|
||||
print('init')
|
||||
self.reset()
|
||||
|
||||
self.send_command(0x01)
|
||||
self.send_data(0x03)
|
||||
self.send_data(0x00)
|
||||
self.send_data(0x2B)
|
||||
self.send_data(0x2B)
|
||||
self.send_data(0x03)
|
||||
|
||||
|
||||
self.send_command(0x06)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
self.send_data(0x17)
|
||||
|
||||
self.send_command(0x04)
|
||||
self.ReadBusy()
|
||||
|
||||
self.send_command(0x00)
|
||||
self.send_data(0xBF)
|
||||
self.send_data(0x0E)
|
||||
|
||||
self.send_command(0x30)
|
||||
self.send_data(0x3A)
|
||||
|
||||
self.send_command(0x61)
|
||||
self.send_data(self.width)
|
||||
self.send_data((self.height&0x100)>>8)
|
||||
self.send_data(self.height&0xff)
|
||||
|
||||
self.send_command(0x82)
|
||||
self.send_data(0x28)
|
||||
|
||||
|
||||
def display(self, image):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
self.send_command(0x10)
|
||||
self.send_data1([0x00] * high * wide)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1(image)
|
||||
|
||||
self.SetFullReg()
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def display_Partial(self, image):
|
||||
self.SetPartReg()
|
||||
self.send_command(0x91)
|
||||
self.send_command(0x90)
|
||||
self.send_data(0)
|
||||
self.send_data(self.width - 1)
|
||||
|
||||
self.send_data(0)
|
||||
self.send_data(0)
|
||||
self.send_data(self.height//256)
|
||||
self.send_data(self.height%256 - 1)
|
||||
self.send_data(0X28)
|
||||
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
self.send_command(0x13)
|
||||
self.send_data1(image)
|
||||
|
||||
self.TurnOnDisplay()
|
||||
|
||||
|
||||
|
||||
def Clear(self, color):
|
||||
high = self.height
|
||||
if( self.width % 8 == 0) :
|
||||
wide = self.width // 8
|
||||
else :
|
||||
wide = self.width // 8 + 1
|
||||
self.send_command(0x10)
|
||||
self.send_data1([color] * high * wide)
|
||||
|
||||
self.send_command(0x13)
|
||||
self.send_data1([~color] * high * wide)
|
||||
|
||||
self.SetFullReg()
|
||||
self.TurnOnDisplay()
|
||||
|
||||
def sleep(self):
|
||||
self.send_command(0x50)
|
||||
self.send_data(0xF7)
|
||||
self.send_command(0x02)
|
||||
self.send_command(0x07)
|
||||
self.send_data(0xA5)
|
||||
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
epd = EPD_2IN9_D()
|
||||
epd.Clear(0x00)
|
||||
|
||||
epd.fill(0xff)
|
||||
epd.text("Waveshare", 5, 10, 0x00)
|
||||
epd.text("ePaper-2.9-D", 5, 40, 0x00)
|
||||
epd.text("Raspberry Pico", 5, 70, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.vline(10, 90, 60, 0x00)
|
||||
epd.vline(120, 90, 60, 0x00)
|
||||
epd.hline(10, 90, 110, 0x00)
|
||||
epd.hline(10, 150, 110, 0x00)
|
||||
epd.line(10, 90, 120, 150, 0x00)
|
||||
epd.line(120, 90, 10, 150, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
epd.rect(10, 180, 50, 80, 0x00)
|
||||
epd.fill_rect(70, 180, 50, 80, 0x00)
|
||||
epd.display(epd.buffer)
|
||||
epd.delay_ms(2000)
|
||||
|
||||
for i in range(0, 10):
|
||||
epd.fill_rect(40, 270, 40, 10, 0xff)
|
||||
epd.text(str(i), 60, 270, 0x00)
|
||||
epd.display_Partial(epd.buffer)
|
||||
|
||||
epd.Clear(0x00)
|
||||
epd.delay_ms(2000)
|
||||
epd.sleep()
|
||||
44
Pico_ePaper_Code/python/ReadmeCN.txt
Normal file
44
Pico_ePaper_Code/python/ReadmeCN.txt
Normal file
@@ -0,0 +1,44 @@
|
||||
/*****************************************************************************
|
||||
* | File : Readme_CN.txt
|
||||
* | Author :
|
||||
* | Function : Help with use
|
||||
* | Info :
|
||||
*----------------
|
||||
* | This version: V1.0
|
||||
* | Date : 2021-03-17
|
||||
* | Info : 在这里提供一个中文版本的使用文档，以便你的快速使用
|
||||
******************************************************************************/
|
||||
这个文件是帮助您使用本例程。
|
||||
在这里简略的描述本工程的使用：
|
||||
|
||||
1.基本信息：
|
||||
本例程使用相对应的模块搭配Pico进行了验证，你可以在工程的中查看对应的测试例程;
|
||||
|
||||
2.管脚连接：
|
||||
管脚连接你可以在Pico_ePaper-xxx.py查看，这里也再重述一次：
|
||||
EPD => Pico
|
||||
VCC -> VSYS
|
||||
GND -> GND
|
||||
DIN -> 11
|
||||
CLK -> 10
|
||||
CS -> 9
|
||||
DC -> 8
|
||||
RST -> 12
|
||||
BUSY -> 13
|
||||
|
||||
3.基本使用：
|
||||
1): 按住Pico板上的按键，将pico通过Micro USB线接到电脑的USB接口，然后松开按键。
|
||||
接入之后，电脑会自动识别到一个可移动盘（RPI-RP2）
|
||||
|
||||
2): 将python目录中Pico.uf2 / Pico 2.uf2 文件复制到识别的可移动盘（RPI-RP2）中
|
||||
|
||||
3): 更新Thonny IDE
|
||||
sudo apt upgrade thonny
|
||||
|
||||
4): 打开Thonny IDE （点击树莓logo -> Programming -> Thonny Python IDE ）
|
||||
选择Tools -> Options... -> Interpreter
|
||||
选择MicroPython(Raspberry Pi Pico 和ttyACM0端口
|
||||
|
||||
5): 在Thonny IDE中打开python/Pico_ePaper-xxx.py文件
|
||||
然后运行当前脚本（绿色小三角）即可
|
||||
|
||||
48
Pico_ePaper_Code/python/ReadmeEN.txt
Normal file
48
Pico_ePaper_Code/python/ReadmeEN.txt
Normal file
@@ -0,0 +1,48 @@
|
||||
/*****************************************************************************
|
||||
* | File : Readme_EN.txt
|
||||
* | Author :
|
||||
* | Function : Help with use
|
||||
* | Info :
|
||||
*----------------
|
||||
* | This version: V1.0
|
||||
* | Date : 2021-03-17
|
||||
* | Info : Here is an English version of the documentation for your quick use.
|
||||
******************************************************************************/
|
||||
This file is to help you use this routine.
|
||||
Here is a brief description of the use of this project:
|
||||
|
||||
1. Basic information:
|
||||
This routine has been verified using the corresponding module with Pico,
|
||||
you can view the corresponding test routine in the project;
|
||||
|
||||
2. Pin connection:
|
||||
You can check the pin connection at Pico_ePaper-xxx.py, and repeat it here:
|
||||
EPD => Pico
|
||||
VCC -> VSYS
|
||||
GND -> GND
|
||||
DIN -> 11
|
||||
CLK -> 10
|
||||
CS -> 9
|
||||
DC -> 8
|
||||
RST -> 12
|
||||
BUSY -> 13
|
||||
|
||||
|
||||
3. Basic use:
|
||||
1): Press and hold the button on the Pico board, connect Pico to the USB port of the
|
||||
computer through the Micro USB cable, and then release the button.
|
||||
After connecting, the computer will automatically recognize a removable disk (RPI-RP2)
|
||||
|
||||
2): Copy the Pico.uf2 / Pico 2.uf2 file in the python directory to the recognized
|
||||
removable disk (RPI-RP2)
|
||||
|
||||
3): Update Thonny IDE
|
||||
sudo apt upgrade thonny
|
||||
|
||||
4): Open Thonny IDE （Click raspberry logo -> Programming -> Thonny Python IDE ）
|
||||
select Tools -> Options... -> Interpreter
|
||||
select MicroPython(Raspberry Pi Pico and ttyACM0 port
|
||||
|
||||
5): Open the python/Pico_ePaper-xxx.py file in Thonny IDE
|
||||
Then run the current script (green triangle)
|
||||
|
||||
BIN
Pico_ePaper_Code/python/Resetting Flash memory/flash_nuke.uf2
Normal file
BIN
Pico_ePaper_Code/python/Resetting Flash memory/flash_nuke.uf2
Normal file
Binary file not shown.
BIN
Pico_ePaper_Code/python/rp2-pico-20220117-v1.18.uf2
Normal file
BIN
Pico_ePaper_Code/python/rp2-pico-20220117-v1.18.uf2
Normal file
Binary file not shown.
Reference in New Issue
Block a user