def displaysettup(self):
"""Setting up the st7789 Display"""
if self.type == "mini":
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
backlight = digitalio.DigitalInOut(board.D22)
reset_pin = None
BAUDRATE = 24000000
if self.type == "gamepad":
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = digitalio.DigitalInOut(board.D24)
backlight = digitalio.DigitalInOut(board.D26)
BAUDRATE = 24000000
# Create the ST7789 display, depending on size:
if self.size == '240x240':
disp = st7789.ST7789(
board.SPI(),
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
height=240,
y_offset=80,
rotation=180
)
elif self.size == '240x135':
# Create the ST7789 display:
disp = st7789.ST7789(
board.SPI(),
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=135,
height=240,
x_offset=53,
y_offset=40,
)
# Turn on the backlight
backlight.switch_to_output()
backlight.value = True
return disp
class Screen:
# Create the ST7789 display:
Disp = st7789.ST7789(
SPI,
rotation=0,
width=240,
height=240,
y_offset=80,
baudrate=BAUDRATE,
cs=digitalio.DigitalInOut(CS_PIN),
dc=digitalio.DigitalInOut(DC_PIN))
currentVC = None
@staticmethod
def size():
return Size(Screen.Disp.width, Screen.Disp.height)
@staticmethod
def setup():
print("Setup Screen")
Screen.runloop()
@staticmethod
def runloop():
print("Start Runloop")
while True:
if Screen.currentVC is not None:
framebuffer = Screen.currentVC.redraw()
framebuffer = framebuffer.resize((Screen.size().width, Screen.size().height))
Screen.Disp.image(framebuffer.convert("RGBA"))
time.sleep(1.0 / FPS)
@staticmethod
def addViewController(VC):
Screen.currentVC = VC
def __init__(self):
self.reset_pin = digitalio.DigitalInOut(board.D27)
self.cs_pin = digitalio.DigitalInOut(board.CE0)
self.dc_pin = digitalio.DigitalInOut(board.D25)
self.BAUDRATE = 24000000
self.spi = board.SPI()
self.disp = st7789.ST7789(self.spi,
height=240,
y_offset=80,
rotation=180,
cs=self.cs_pin,
dc=self.dc_pin,
rst=self.reset_pin,
baudrate=self.BAUDRATE)
self.image = Image.new("RGB", (240, 240))
self.draw = ImageDraw.Draw(self.image)
# fonts_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'fonts')
self.font_small = ImageFont.truetype(
"/usr/share/fonts/truetype/open-sans/OpenSans-Light.ttf", 14)
self.font_middle = ImageFont.truetype(
"/usr/share/fonts/truetype/open-sans/OpenSans-Light.ttf", 24)
self.font_big = ImageFont.truetype(
"/usr/share/fonts/truetype/open-sans/OpenSans-Light.ttf", 40)
self.pages = list()
self.page_black = None
self.current_page = 0
self.screen_enabled = True
self.page_change = False
def __init__(self, refresh_rate=600, width=240, height=240):
self.get_stats_interval_sec = refresh_rate
self.width = width
self.height = height
self.logger = logging.getLogger(__name__)
self.logger.propagate = False
self.logger.addHandler(journal.JournaldLogHandler())
self.logger.setLevel(logging.INFO)
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
BAUDRATE = 64000000
self.display = st7789.ST7789(board.SPI(),
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=width,
height=height,
y_offset=80,
rotation=180)
backlight = digitalio.DigitalInOut(board.D22)
backlight.switch_to_output()
backlight.value = True
self.buttonA = digitalio.DigitalInOut(board.D23)
self.buttonB = digitalio.DigitalInOut(board.D24)
self.buttonA.switch_to_input()
self.buttonB.switch_to_input()
self._button_hold_time = 2.0
self.image = Image.new("RGB", (width, height))
self.draw = ImageDraw.Draw(self.image)
self.draw.rectangle((0, 0, width, height), outline=0, fill=(0, 0, 0))
self.display.image(self.image) #, rotation)
self.dejavu = ImageFont.truetype(
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 24)
self.roboto = ImageFont.truetype(
"/usr/share/fonts/truetype/roboto/unhinted/Roboto-Black.ttf", 24)
self.blue = "#007bff"
self.indigo = "#6610f2"
self.purple = "#6f42c1"
self.pink = "#e83e8c"
self.red = "#dc3545"
self.orange = "#fd7e14"
self.yellow = "#ffc107"
self.green = "#28a745"
self.teal = "#20c997"
self.cyan = "#17a2b8"
self.gray = "#6c757d"
self.gray_dark = "#343a40"
self.stats = CovidStats()
loop = asyncio.get_event_loop()
loop.create_task(self.update_loop())
def __init__(self, conf_path=util.CONF, env_path=util.ENV):
with open(conf_path) as cf:
self.conf = json.load(cf)
with open(env_path) as ef:
self.env = json.load(ef)
self.lock = asyncio.Lock()
self.i2s_lock = asyncio.Lock()
self.mic_int = False
self.event_loop = asyncio.get_running_loop()
self.button = Button(self.conf['button'])
self._double_press_threshold = .5
self.cam = None
spi = board.SPI()
cs_pin = digitalio.DigitalInOut(
getattr(board, f'D{self.conf["screen"]["cs"]}'))
dc_pin = digitalio.DigitalInOut(
getattr(board, f'D{self.conf["screen"]["dc"]}'))
reset_pin = digitalio.DigitalInOut(
getattr(board, f'D{self.conf["screen"]["rst"]}'))
self.screen = st7789.ST7789(
spi,
rotation=90,
width=135,
height=240,
x_offset=53,
y_offset=40,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=24000000,
)
try: # the try-catch is for testing the server without servo driver connected
self.servokit = ServoKit(channels=16,
freq=self.conf['servo']['freq'])
self.screen_backlight = self.servokit.servo[
self.conf['servo']['backlight']['channel']]
self.screen_backlight.set_pulse_width_range(
0, 1000000 // self.conf['servo']['freq'])
self.screen_backlight.fraction = 0
self.speaker_power = self.servokit.servo[self.conf['servo']
['speaker']['channel']]
self.speaker_power.set_pulse_width_range(
0, 1000000 // self.conf['servo']['freq'])
self.speaker_power.fraction = 0
self.servo_update_rate = self.conf['servo']['update_rate']
self.reset_servos()
self._head.angle = self.rarm.fraction = self.larm.fraction = 0
time.sleep(.5)
self.relax_lift()
self.relax_head()
except Exception as e:
print(e)
def __init__(self, refresh_rate=0.5, data_points=61):
self._disp = st7789.ST7789(board.SPI(),
baudrate=64000000,
cs=digitalio.DigitalInOut(board.D4),
dc=digitalio.DigitalInOut(board.D5),
rst=digitalio.DigitalInOut(board.D6),
width=135,
height=240,
x_offset=53,
y_offset=40)
self._height = self._disp.width # we swap height/width to rotate it to landscape!
self._width = self._disp.height
self._image = Image.new('RGB', (self._width, self._height))
self._rotation = 90
self._draw = ImageDraw.Draw(self._image)
self._draw.rectangle((0, 0, self._width, self._height),
outline=0,
fill=0)
self._disp.image(self._image, self._rotation)
#self._font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', 24)
x_time = [x * refresh_rate for x in range(data_points)]
x_time.reverse()
self._y_data = [[
deque([None] * data_points, maxlen=data_points)
for _ in Ui.PLOT_CONFIG['line_config']
]]
plt.style.use('dark_background')
fig, self._ax = plt.subplots(figsize=(self._disp.width / 100,
self._disp.height / 100))
self._ax.xaxis.set_ticklabels([])
self._ax.grid(True, linestyle=':')
self._ax.set_xlim(min(x_time), max(x_time))
self._ax.invert_xaxis()
if 'title' in Ui.PLOT_CONFIG:
self._ax.set_title(Ui.PLOT_CONFIG['title'], position=(0.5, 0.8))
if 'ylim' in Ui.PLOT_CONFIG:
self._ax.set_ylim(Ui.PLOT_CONFIG['ylim'])
self._plot_lines = []
for index, line_config in enumerate(Ui.PLOT_CONFIG['line_config']):
line, = self._ax.plot(x_time, self._y_data[index])
if 'color' in line_config:
line.set_color(line_config['color'])
if 'width' in line_config:
line.set_linewidth(line_config['width'])
if 'style' in line_config:
line.set_linestyle(line_config['style'])
self._plot_lines.append(line)
self._t_poll = None
self._running = False
self._refresh_rate = refresh_rate
atexit.register(self._cleanup)
def setup(self, setupDisplay):
if setupDisplay:
import board
from digitalio import DigitalInOut, Direction
import adafruit_rgb_display.st7789 as st7789
print("Setting up Adafruit st7789 driver...")
# Create the display
cs_pin = DigitalInOut(board.CE0)
dc_pin = DigitalInOut(board.D25)
reset_pin = DigitalInOut(board.D24)
BAUDRATE = 24000000
spi = board.SPI()
self.display = st7789.ST7789(spi,
width=self.width,
height=self.height,
y_offset=80,
rotation=self.rotation,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE)
# Get the Adafruit 1.3" TFT Bonnet Buttons
# Input pins:
button_A = DigitalInOut(board.D5)
button_A.direction = Direction.INPUT
button_B = DigitalInOut(board.D6)
button_B.direction = Direction.INPUT
button_L = DigitalInOut(board.D27)
button_L.direction = Direction.INPUT
button_R = DigitalInOut(board.D23)
button_R.direction = Direction.INPUT
button_U = DigitalInOut(board.D17)
button_U.direction = Direction.INPUT
button_D = DigitalInOut(board.D22)
button_D.direction = Direction.INPUT
button_C = DigitalInOut(board.D4)
button_C.direction = Direction.INPUT
self.buttons['A'] = button_A
self.buttons['B'] = button_B
self.buttons['LEFT'] = button_L
self.buttons['RIGHT'] = button_R
self.buttons['UP'] = button_U
self.buttons['DOWN'] = button_D
self.buttons['STICK'] = button_C
else:
print("Not using Adafruit Driver.")
def __init__(self, cwd):
# Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4):
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D1)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 64000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
self.disp = st7789.ST7789(
spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=135,
height=240,
x_offset=53,
y_offset=40,
)
# Create blank image for drawing.
# Make sure to create image with mode '1' for 1-bit color.
self.width = self.disp.width - 1
self.height = self.disp.height - 1
padding = 0
self.top = padding
self.bottom = self.height - padding
self.image = Image.new("RGB", (self.height, self.width))
# Get drawing object to draw on image.
self.draw = ImageDraw.Draw(self.image)
# Draw a black filled box to clear the image.
#self.draw.rectangle((0, 0, self.height, self.width), outline=0, fill=0)
# Font
self.font_size = 30
self.font = ImageFont.truetype(
'/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', self.font_size)
self.splash_font_size = 40
self.splash_font = ImageFont.truetype(
'/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',
self.splash_font_size)
# Splash
self.splash_show()
def __init__(self):
self._backlight_pin.switch_to_output()
self._backlight_pin.value = True
self._disp = st7789.ST7789(
spi,
cs=self._cs_pin,
dc=self._dc_pin,
rst=self._reset_pin,
baudrate=self._BAUDRATE,
width=self.
height, # we swap height/width to rotate it to landscape!
height=self.width,
x_offset=53,
y_offset=40,
)
def __init__(self,
background="black",
foreground="white",
rotation=270,
padding=-2,
width=135,
height=240,
x_offset=53,
y_offset=40,
baudrate=64000000,
ttfont='dejavu/DejaVuSans.ttf',
fontsize=24):
# Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4):
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
self.__disp = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=baudrate,
width=width,
height=height,
x_offset=x_offset,
y_offset=y_offset)
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
self.__height = self.__disp.width # we swap height/width to rotate it to landscape!
self.__width = self.__disp.height
self.__image = Image.new('RGB', (self.__width, self.__height))
self.__rotation = rotation
self.__padding = padding
self.__background = background
self.__foreground = foreground
# Get drawing object to draw on image.
self.__draw = ImageDraw.Draw(self.__image)
self.clear()
self.backlight(False)
self.setFont(fontsize, ttfont)
def __init__(self, conf_path=util.CONF, env_path=util.ENV):
with open(conf_path) as cf:
self.conf = json.load(cf)
with open(env_path) as ef:
self.env = json.load(ef)
self.lock = asyncio.Lock()
self.event_loop = asyncio.get_running_loop()
self.button = Button(self.conf['button'])
self.buzzer = TonalBuzzer(self.conf['buzzer'])
self.servokit = ServoKit(channels=16, freq=self.conf['servo']['freq'])
self.screen_backlight = self.servokit.servo[self.conf['servo']
['backlight']['channel']]
self.screen_backlight.set_pulse_width_range(
0, 100000 // self.conf['servo']['freq'])
self.screen_backlight.fraction = 0
spi = board.SPI()
cs_pin = digitalio.DigitalInOut(
getattr(board, f'D{self.conf["screen"]["cs"]}'))
dc_pin = digitalio.DigitalInOut(
getattr(board, f'D{self.conf["screen"]["dc"]}'))
reset_pin = digitalio.DigitalInOut(
getattr(board, f'D{self.conf["screen"]["rst"]}'))
self.screen = st7789.ST7789(
spi,
rotation=90,
width=135,
height=240,
x_offset=53,
y_offset=40,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=24000000,
)
self.servo_update_rate = self.conf['servo']['update_rate']
self._double_press_max_interval = .5
self.reset_servos()
self._head.angle = self.rarm.fraction = self.larm.fraction = 0
time.sleep(.5)
self.relax_lift()
self.relax_head()
self.cam = None
def __init__(self):
# Create the ST7789 display:
self.disp = st7789.ST7789(
board.SPI(), # Setup SPI bus using hardware SPI
cs=digitalio.DigitalInOut(
board.CE0
), # Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4)
dc=digitalio.DigitalInOut(board.D25),
rst=None,
baudrate=
64000000, # Config for display baudrate (default max is 24mhz)
width=135,
height=240,
x_offset=53,
y_offset=40,
)
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
self.height = self.disp.width # we swap height/width to rotate it to landscape!
self.width = self.disp.height
self.image = Image.new("RGB", (self.width, self.height))
self.rotation = 90
# Text helping things
self.padding = -2
self.top = self.padding
self.bottom = self.height - self.padding
# Move left to right keeping track of the current x position for drawing shapes.
self.x = 0
self.y = self.top
# Alternatively load a TTF font. Make sure the .ttf font file is in the
# same directory as the python script!
# Some other nice fonts to try: http://www.dafont.com/bitmap.php
self.font = ImageFont.truetype(
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 18)
# Get drawing object to draw on image.
self.draw = ImageDraw.Draw(self.image)
self.blank()
self.commit()
self.backlight = Backlight()
self.backlight.on()
def __init__(self, width: int, height: int):
super().__init__()
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
self.backlight_pin = digitalio.DigitalInOut(board.D22)
self.backlight_pin.switch_to_output()
BAUDRATE = 64000000
self.display = st7789.ST7789(
board.SPI(),
cs=cs_pin,
dc=dc_pin,
baudrate=BAUDRATE,
width=width,
height=height,
x_offset=0,
y_offset=80, # needed for 240x240 display
)
def _initDisplay(self):
"""
Set up the display board.
"""
# Create the ST7789 display object
self._disp = st7789.ST7789(
board.SPI(),
cs=digitalio.DigitalInOut(board.CE0),
dc=digitalio.DigitalInOut(board.D25),
rst=None,
baudrate=64000000,
width=240,
height=240,
x_offset=0,
y_offset=80,
)
# for convenience
self._width = self._disp.height
self._height = self._disp.width
self._image = Image.new("RGB", (self._width, self._height))
self._draw = ImageDraw.Draw(self._image)
self.clearScreen()
padding = -2
self._yTop = padding
bottom = self._height - padding
self._font = ImageFont.truetype(
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 24)
self._fontHeight = self._font.getsize("X")[1]
self._setupGPIO()
# Turn on the backlight
self._backlight = digitalio.DigitalInOut(board.D22)
self._backlight.switch_to_output()
self._backlight.value = True
def displaysettup():
"""Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4)"""
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 64000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
disp = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=135,
height=240,
x_offset=53,
y_offset=40)
return disp
def init_LCD():
# Configuration for CS and DC pins
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = digitalio.DigitalInOut(board.D24)
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 24000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the display:
return st7789.ST7789(
spi,
height=240,
y_offset=80,
rotation=180,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
bauadrate=BAUDRATE
)
def __init__(self, user_interface):
self.user_interface = user_interface
self.cs_pin = DigitalInOut(board.CE0)
self.dc_pin = DigitalInOut(board.D25)
self.reset_pin = DigitalInOut(board.D24)
self.baudrate = 24000000
self.spi = board.SPI()
self.display = st7789.ST7789(self.spi,
height=240,
y_offset=80,
rotation=180,
cs=self.cs_pin,
dc=self.dc_pin,
rst=self.reset_pin,
baudrate=self.baudrate)
self.button_A = DigitalInOut(board.D5)
self.button_A.direction = Direction.INPUT
self.button_B = DigitalInOut(board.D6)
self.button_B.direction = Direction.INPUT
self.button_Left = DigitalInOut(board.D27)
self.button_Left.direction = Direction.INPUT
self.button_Right = DigitalInOut(board.D23)
self.button_Right.direction = Direction.INPUT
self.button_Up = DigitalInOut(board.D17)
self.button_Up.direction = Direction.INPUT
self.button_Down = DigitalInOut(board.D22)
self.button_Down.direction = Direction.INPUT
self.button_Select = DigitalInOut(board.D4)
self.button_Select.direction = Direction.INPUT
self.backlight = DigitalInOut(board.D26)
self.backlight.switch_to_output()
self.backlight.value = True
self.USB_last_time = time.time()
self.USB_refresh_time = 5.0
self.USB_previous = False
self.USB_found = False
self.screen = screen(self, self.user_interface)
# board.SPI(),
# cs=cs_pin,
# dc=dc_pin,
# baudrate=BAUDRATE,
# width=135,
# height=240,
# x_offset=53,
# y_offset=40,
# rotation=270,
#)
# full height adafruit screen 1.3" (240x240), two buttons
disp = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
baudrate=BAUDRATE,
height=240,
y_offset=80,
rotation=180)
# don't write to display concurrently with thread
display_lock = threading.Lock()
# Create image and drawing object
if disp.rotation % 180 == 90:
height = disp.width # we swap height/width to rotate it to landscape!
width = disp.height
else:
width = disp.width # we swap height/width to rotate it to landscape!
height = disp.height
image = Image.new("RGBA", (width, height))
value_api_url = "https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd"
# Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4):
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.CE1)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 24000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
disp = st7789.ST7789(spi, cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=BAUDRATE,
rotation=90, width=280, height=290, x_offset=30, y_offset=30)
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
height = disp.width # we swap height/width to rotate it to landscape!
width = disp.height
image = Image.new('RGB', (width, height, rotation))
# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
# Draw a black filled box to clear the image.
draw.rectangle((0, 0, width, height), fill=(255, 255, 255))
disp.image(image, rotation)
# Draw some shapes.
# First define some constants to allow easy resizing of shapes.
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 24000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
disp = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=290,
height=290,
x_offset=50,
y_offset=50)
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
height = disp.width # we swap height/width to rotate it to landscape!
width = disp.height
image = Image.new('RGB', (width, height))
rotation = 90
# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
spi = board.SPI()
# pylint: disable=line-too-long
# Create the display:
# disp = st7789.ST7789(spi, rotation=90, # 2.0" ST7789
disp = st7789.ST7789(spi, height=240, y_offset=80, rotation=180, # 1.3", 1.54" ST7789
# disp = st7789.ST7789(spi, rotation=90, width=135, height=240, x_offset=53, y_offset=40, # 1.14" ST7789
# disp = hx8357.HX8357(spi, rotation=180, # 3.5" HX8357
# disp = st7735.ST7735R(spi, rotation=90, # 1.8" ST7735R
# disp = st7735.ST7735R(spi, rotation=270, height=128, x_offset=2, y_offset=3, # 1.44" ST7735R
# disp = st7735.ST7735R(spi, rotation=90, bgr=True, # 0.96" MiniTFT ST7735R
# disp = ssd1351.SSD1351(spi, rotation=180, # 1.5" SSD1351
# disp = ssd1351.SSD1351(spi, height=96, y_offset=32, rotation=180, # 1.27" SSD1351
# disp = ssd1331.SSD1331(spi, rotation=180, # 0.96" SSD1331
disp = ili9341.ILI9341(
spi,
rotation=90, # 2.2", 2.4", 2.8", 3.2" ILI9341
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
)
# pylint: enable=line-too-long
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
if disp.rotation % 180 == 90:
height = disp.width # we swap height/width to rotate it to landscape!
width = disp.height
else:
width = disp.width # we swap height/width to rotate it to landscape!
height = disp.height
# The gateway address and host address are expected to be in the environment
GATEWAY = os.environ['GATEWAY']
IPADDR = os.environ['IPADDR']
# Commands to check LAN, WAN, etc.
LAN_COMMAND = 'curl -sS https://' + GATEWAY + ' 2>/dev/null | wc -l'
WAN_COMMAND = 'curl -sS https://google.com 2>/dev/null | wc -l'
UPTIME_COMMAND = "uptime | awk '{printf \"up %s avg %.2f\", $3, $(NF-2)}'"
# Setup the display:
BAUDRATE = 24000000
spi = board.SPI()
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = digitalio.DigitalInOut(board.D24)
disp = st7789.ST7789(spi, rotation=90, cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=BAUDRATE)
# Create an 'RGB' drawing canvas
if disp.rotation % 180 == 90:
# Swap height/width when rotating to landscape!
height = disp.width
width = disp.height
else:
width = disp.width
height = disp.height
original = Image.new('RGB', (width, height))
draw = ImageDraw.Draw(original)
# Draw a white filled box to clear the image.
draw.rectangle((0, 0, width, height), outline=0, fill="#FFFFFF")
disp.image(original)
value_api_url = "https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd"
# Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4):
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 16000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
disp = st7789.ST7789(spi, cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=BAUDRATE,
width=320, height=480, invert=True, x_offset=0, y_offset=0)
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
height = disp.width # we swap height/width to rotate it to landscape!
width = disp.height
image = Image.new('RGB', (width, height))
rotation = 90
setRotation(2)
# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
# Draw a black filled box to clear the image.
draw.rectangle((0, 0, width, height), fill=(255,255,255))
disp.image(image, rotation)
# Draw some shapes.
def _SetupDisplaySt7789(self, clv_OutputDisplay):
rtn = True
# ----------------------------------------------------------------------
# Create the ST7789 display (this is 240x240 version):
# ----------------------------------------------------------------------
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
BAUDRATE = 64000000 # Default max is 24Mhz
try:
spi = board.SPI() # Setup SPI bus using hardware SPI
except Exception as e:
logfile.Console("OLED display st7789 cannot be initialized: %s" %
e)
rtn = False
else:
# ------------------------------------------------------------------
# Now initialize the display
# ------------------------------------------------------------------
self.st7789 = st7789.ST7789(
spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=240,
height=240,
x_offset=0,
y_offset=80,
)
# ------------------------------------------------------------------
# As copied from https://learn.adafruit.com
# For testing
# ------------------------------------------------------------------
self.backlight = digitalio.DigitalInOut(board.D22)
self.backlight.switch_to_output()
self.backlight.value = True
assert (clv_OutputDisplay in ('st7789', 'st7789b'))
if clv_OutputDisplay == 'st7789':
self.buttonA = digitalio.DigitalInOut(board.D23)
self.buttonB = digitalio.DigitalInOut(board.D24)
elif clv_OutputDisplay == 'st7789b': # Add Waveshare 1.3 LCD
self.buttonA = digitalio.DigitalInOut(board.D20)
self.buttonB = digitalio.DigitalInOut(board.D16)
# --------------------------------------------------------------
# The Waveshare is missing the reset circuit from the Adafruit
# display, the reset_pin needs to be defined.
# --------------------------------------------------------------
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = digitalio.DigitalInOut(board.D27)
self.buttonA.switch_to_input(digitalio.Pull.UP)
self.buttonB.switch_to_input(digitalio.Pull.UP)
self.ButtonDefaultValue = self.buttonA.value
# ------------------------------------------------------------------
# Startup image is in directory of the .py [or embedded in .exe]
# ------------------------------------------------------------------
dirname = os.path.dirname(__file__)
FortiusAnt_jpg = os.path.join(dirname, "FortiusAnt.jpg")
self.faImage = Image.open(FortiusAnt_jpg)
# ------------------------------------------------------------------
# Scale the image to the smaller screen dimension:
# ------------------------------------------------------------------
image_ratio = self.faImage.width / self.faImage.height
screen_ratio = self.st7789.width / self.st7789.height
if screen_ratio < image_ratio:
scaled_width = self.faImage.width * self.st7789.height // self.faImage.height
scaled_height = self.st7789.height
else:
scaled_width = self.st7789.width
scaled_height = self.faImage.height * self.st7789.width // self.faImage.width
self.faImage = self.faImage.resize((scaled_width, scaled_height),
Image.BICUBIC)
# ------------------------------------------------------------------
# Crop and center the image:
# ------------------------------------------------------------------
x_jpg = scaled_width // 2 - self.st7789.width // 2
y_jpg = scaled_height // 2 - self.st7789.height // 2
self.faImage = self.faImage.crop(
(x_jpg, y_jpg, x_jpg + self.st7789.width,
y_jpg + self.st7789.height))
#-------------------------------------------------------------------
# Load a TTF font - other good fonts available from: http://www.dafont.com/bitmap.php
#-------------------------------------------------------------------
self.fontS = ImageFont.truetype(
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 22)
self.fontLb = ImageFont.truetype(
"/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 36)
# ------------------------------------------------------------------
# Display image, for at least three seconds
# ------------------------------------------------------------------
self._ShowImage()
time.sleep(3)
#-------------------------------------------------------------------
# Part 2: display control text
# Create blank image for drawing with mode 'RGB' for full color
# Get drawing object to draw on image
#-------------------------------------------------------------------
self.image = Image.new("RGB",
(self.st7789.width, self.st7789.height))
self.draw = ImageDraw.Draw(self.image)
return rtn
import webcolors
# The display uses a communication protocol called SPI.
# SPI will not be covered in depth in this course.
# you can read more https://www.circuitbasics.com/basics-of-the-spi-communication-protocol/
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
BAUDRATE = 64000000 # the rate the screen talks to the pi
# Create the ST7789 display:
display = st7789.ST7789(
board.SPI(),
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=135,
height=240,
x_offset=53,
y_offset=40,
)
# these setup the code for our buttons and the backlight and tell the pi to treat the GPIO pins as digitalIO vs analogIO
backlight = digitalio.DigitalInOut(board.D22)
backlight.switch_to_output()
backlight.value = True
buttonA = digitalio.DigitalInOut(board.D23)
buttonB = digitalio.DigitalInOut(board.D24)
buttonA.switch_to_input()
buttonB.switch_to_input()
# Configuratoin for CS and DC pins (these are FeatherWing defaults on M0/M4):
cs_pin = digitalio.DigitalInOut(board.D5)
dc_pin = digitalio.DigitalInOut(board.D6)
reset_pin = digitalio.DigitalInOut(board.D9)
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 24000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
display = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE)
# Main loop:
while True:
# Fill the screen red, green, blue, then black:
for color in ((255, 0, 0), (0, 255, 0), (0, 0, 255)):
display.fill(color565(color))
# Clear the display
display.fill(0)
# Draw a red pixel in the center.
display.pixel(display.width // 2, display.height // 2, color565(255, 0, 0))
# Pause 2 seconds.
time.sleep(2)
# Clear the screen a random color
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 64000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
disp = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=135,
height=240,
x_offset=53,
y_offset=40)
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
height = disp.width # we swap height/width to rotate it to landscape!
width = disp.height
image = Image.new('RGB', (width, height))
rotation = 90
# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
# Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4):
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 16000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
disp = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=480,
height=320)
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
height = disp.width # we swap height/width to rotate it to landscape!
width = disp.height
image = Image.new('RGB', (width, height))
rotation = 90
setRotation = 2
# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
# Configuratoin for CS and DC pins (these are FeatherWing defaults on M0/M4):
cs_pin = digitalio.DigitalInOut(board.D5)
dc_pin = digitalio.DigitalInOut(board.D6)
reset_pin = digitalio.DigitalInOut(board.D9)
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 24000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display: adjust x / y offsets depending on rotation and your screen (often by 80)
display = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
x_offset=0,
y_offset=0,
rotation=0,
baudrate=BAUDRATE)
# Main loop:
while True:
# Fill the screen red, green, blue, then black:
for color in ((255, 0, 0), (0, 255, 0), (0, 0, 255)):
display.fill(color565(color))
# Clear the display
display.fill(0)
# Draw a red pixel in the center.
display.pixel(display.width // 2, display.height // 2, color565(255, 0, 0))
# Pause 2 seconds.
time.sleep(2)
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 24000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Create the ST7789 display:
disp = st7789.ST7789(spi,
cs=cs_pin,
dc=dc_pin,
rst=reset_pin,
baudrate=BAUDRATE,
width=318,
height=478,
x_offset=20,
y_offset=20)
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
height = disp.width # we swap height/width to rotate it to landscape!
width = disp.height
image = Image.new('RGB', (width, height))
rotation = 90
# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
