def __init__(self):
self.display = InkyPHAT("black")
self.display.set_border(self.display.WHITE)
self.font = ImageFont.truetype('resources/Eden_Mills_Bold.ttf', 12)
self.lock = threading.Lock()
self.startup()
def __init__(self):
self.debug = False
self.display = None
self.current = None
self.last = None
self.last_load = None
self.bg = None
self.noaa = None
self.darksky = None
self.btn_down = False
if args.debug is 'true' or args.debug is 'True':
self.debug = True
if pzwglobals.RUN_ON_RASPBERRY_PI:
self.display = InkyPHAT("yellow")
self.display.set_border(WHITE)
self.screens = {
'current_weather':
CurrentWeather('current_weather',
debug=self.debug,
display=self.display),
'forecast_days':
ForecastDays('forecast_days',
debug=self.debug,
display=self.display)
}
def __init__(self, rotation=180):
self.inky_display = InkyPHAT("red")
self.inky_display.set_border(self.inky_display.BLACK)
self.WIDTH = self.inky_display.WIDTH
self.HEIGHT = self.inky_display.HEIGHT
self.WHITE = self.inky_display.WHITE
self.RED = self.inky_display.RED
self.BLACK = self.inky_display.BLACK
self.rotation = 180
def __init__(self,
color="red",
font_type=FredokaOne,
font_size=20,
more_text_postfix="..."):
self.inkyphat = InkyPHAT(color)
self.color = self.__get_inky_color(color)
self.more_text_postfix = more_text_postfix
self.img = Image.new("P", (self.inkyphat.WIDTH, self.inkyphat.HEIGHT))
self.font = ImageFont.truetype(font_type, font_size)
def __init__(self):
# Start by loading the word list
with open('longwords.txt', 'r') as f:
self.word_list = f.read().splitlines()
self.d = InkyPHAT("red")
self.d.set_border(self.d.RED)
self.d.h_flip = True
self.d.v_flip = True
self.font = ImageFont.load("font.pil")
def __init__(self, display_resources, sensors, weather_info, moon_info):
self.__logger = logging.getLogger(self.__class__.__name__)
self.__resources = display_resources
self.__sensors = sensors
self.__weather_info = weather_info
self.__moon_info = moon_info
self.__display = InkyPHAT('yellow')
self.__display.set_border(InkyPHAT.BLACK)
self.__screen_image = Image.open(self.__resources['background'])
self.__digit_fonts = {}
for name, font in self.__resources['digit-fonts'].items():
self.__digit_fonts[name] = Font(font)
self.__labels = {}
for name, label in self.__resources['labels'].items():
self.__labels[name] = Font(label)
self.__weather_icons_day = {}
self.__weather_icons_night = {}
for _, icon in self.__resources['weather-icons'].items():
day = Icon(icon['day'])
night = Icon(icon['night'])
for code in icon['codes']:
self.__weather_icons_day[code] = day
self.__weather_icons_night[code] = night
self.__moon_icons = {}
for name, icon in self.__resources['moon-icons'].items():
self.__moon_icons[name] = Icon(icon)
self.__power_icons = {}
for name, icon in self.__resources['power-icons'].items():
self.__power_icons[name] = Icon(icon)
self.__old_temperature = None
self.__old_humidity = None
self.__old_pressure = None
self.__old_date = None
self.__old_sunset_time = None
self.__old_sunrise_time = None
self.__old_today_forecast = None
self.__old_tomorrow_forecast = None
self.__old_is_daytime = None
self.__old_next_moon_phase = None
self.__old_next_moon_phase_date = None
self.__old_uv_index = None
#initialize gpio ofr power monitoring
self.__main_line = gpiozero.Button(pin=5, pull_up=False)
self.__main_line.when_activated = self.__on_power_state_changed
self.__main_line.when_deactivated = self.__on_power_state_changed
self.__battery_low = gpiozero.Button(pin=6, pull_up=False)
self.__battery_low.when_activated = self.__on_power_state_changed
self.__battery_low.when_deactivated = self.__on_power_state_changed
#set default power icon icon (battery low)
self.__power_state = None
self.__on_power_state_changed()
def displayInky(output):
from PIL import Image, ImageFont, ImageDraw
from inky import InkyPHAT
inky_display = InkyPHAT("red")
inky_display.set_border(inky_display.RED)
img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT))
draw = ImageDraw.Draw(img)
headerSize = 12
headerFont = ImageFont.truetype(
"/usr/share/fonts/truetype/liberation2/LiberationSans-Bold.ttf",
headerSize)
messageFont = ImageFont.truetype(
"/usr/share/fonts/truetype/liberation2/LiberationMono-Regular.ttf",
int(75 / (output['bodyLines'])))
x = 0
y = 0
draw.text((x, y), output['header'] + ' - ' + output['subHeader'],
inky_display.RED, headerFont)
draw.text((x, y + headerSize), output['body'], inky_display.BLACK,
messageFont)
inky_display.set_image(img)
inky_display.show()
def initialiseDisplay():
"""
Basic setup of display
Inputs: None
Return Values: None
Global Objects Created: inkyDisplay (instance of inkyPHAT)
"""
global inkyDisplay
inkyDisplay = InkyPHAT(deviceColour)
# I think we do this here.
inkyDisplay.set_border(inkyDisplay.WHITE)
inkyDisplay.set_border(inkyDisplay.BLACK)
def _init_display(self):
if self._is_inky():
from inky import InkyPHAT
self._display = InkyPHAT(self._display_color)
self._display.set_border(InkyPHAT.BLACK)
self._render_cb = self._inky_render
elif self._is_waveshare1():
from pwnagotchi.ui.waveshare.v1.epd2in13 import EPD
# core.log("display module started")
self._display = EPD()
self._display.init(self._display.lut_full_update)
self._display.Clear(0xFF)
self._display.init(self._display.lut_partial_update)
self._render_cb = self._waveshare_render
elif self._is_waveshare2():
from pwnagotchi.ui.waveshare.v2.waveshare import EPD
# core.log("display module started")
self._display = EPD()
self._display.init(self._display.FULL_UPDATE)
self._display.Clear(WHITE)
self._display.init(self._display.PART_UPDATE)
self._render_cb = self._waveshare_render
else:
core.log("unknown display type %s" % self._display_type)
self.on_render(self._on_view_rendered)
core.log("display type '%s' initialized (color:%s)" % (self._display_type, self._display_color))
def initialize(self):
logging.info("initializing inky display")
if self.config['color'] == 'fastAndFurious':
logging.info("Initializing Inky in 2-color FAST MODE")
logging.info(
"THIS MAY BE POTENTIALLY DANGEROUS. NO WARRANTY IS PROVIDED")
logging.info("USE THIS DISPLAY IN THIS MODE AT YOUR OWN RISK")
from pwnagotchi.ui.hw.libs.inkyphat.inkyphatfast import InkyPHATFast
self._display = InkyPHATFast('black')
self._display.set_border(InkyPHATFast.BLACK)
else:
from inky import InkyPHAT
self._display = InkyPHAT(self.config['color'])
self._display.set_border(InkyPHAT.BLACK)
def test_init_phat_black():
"""Test initialisation of InkyPHAT with 'black' colour choice."""
mockery()
from inky import InkyPHAT
InkyPHAT('black')
def test_init_phat_yellow():
"""Test initialisation of InkyPHAT with 'yellow' colour choice."""
mockery()
from inky import InkyPHAT
InkyPHAT('red')
def main():
"""Get desk status from API."""
parser = argparse.ArgumentParser()
parser.add_argument("--desk-id",
"-i",
type=str,
required=True,
help="Desk unique identifier")
parser.add_argument(
"--url",
"-u",
type=str,
default="http://127.0.0.1:5000",
help="URL of the REST API, from where statuses are obtained")
clargs = parser.parse_args()
inky_display = InkyPHAT(COLOUR)
status = requests.get("/".join([clargs.url, clargs.desk_id])).json()
update_display(inky_display,
status["status"],
clargs.desk_id,
name=status["name"],
until=status["until"])
def main():
"""Set desk status 'offline'."""
parser = argparse.ArgumentParser()
parser.add_argument(
"--status",
"-s",
type=str,
required=True,
choices=["taken", "free"],
help="The status of the desk, either 'taken' or 'free'")
parser.add_argument(
"--desk-id",
"-i",
type=str,
required=True,
help="A unique identifier for the desk (used for booking)")
parser.add_argument(
"--name",
"-n",
type=str,
required=False,
help="The name of the person who has reserved the desk")
parser.add_argument("--until",
"-u",
type=str,
required=False,
help="The time when a desk is free until")
clargs = parser.parse_args()
inky_display = InkyPHAT(COLOUR)
update_display(inky_display, clargs.status, clargs.desk_id, clargs.name,
clargs.until)
def hype(word):
print(word)
# Set up the correct display and scaling factors
inky_display = InkyPHAT('black')
inky_display.set_border(inky_display.BLACK)
# inky_display.set_rotation(180)
w = inky_display.WIDTH
h = inky_display.HEIGHT
# Create a new canvas to draw on
img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT))
draw = ImageDraw.Draw(img)
# Load the fonts
font_size = 88
from fonts.ttf import AmaticSC, FredokaOne
#font = ImageFont.truetype(SourceSansProSemibold, font_size)
font = ImageFont.truetype(AmaticSC, font_size)
#font = ImageFont.truetype(FredokaOne, font_size)
padding = 20
max_width = w - padding
max_height = h - padding
below_max_length = False
while not below_max_length:
p_w, p_h = font.getsize(word) # Width and height of quote
#p_h = p_h * (word.count("\n") + 1) # Multiply through by number of lines
if p_h < max_height and p_w < max_width:
below_max_length = True # The quote fits! Break out of the loop.
else:
font_size = font_size - 2
#font = ImageFont.truetype(SourceSansProSemibold, font_size)
font = ImageFont.truetype(AmaticSC, font_size)
#font = ImageFont.truetype(FredokaOne, font_size)
continue
# x- and y-coordinates for the top left of the quote
#word_x = (w - max_width) / 2
#word_x = (max_width - p_w) / 2
#word_y = (max_height - p_h) / 2
word_x = (w - max_width) / 2
#word_y = ((h - max_height) + (max_height - p_h - font.getsize("ABCD ")[1])) / 2
word_y = (h - p_h) / 2
draw.multiline_text((word_x, word_y), word, fill=inky_display.BLACK, font=font, align="left")
draw.line((169, 58, 169, 58), 2)
# Display the completed canvas on Inky wHAT
inky_display.set_image(img)
inky_display.show()
class RenderQueue():
def __init__(self):
self.img_stack = []
self.inky_display = InkyPHAT("black")
pub.subscribe(self.add_image, 'add_image')
def add_image(self, img):
self.img_stack.append(img)
def run(self):
while True:
if len(self.img_stack) > 0:
most_recent_frame = self.img_stack.pop()
self.img_stack = []
self.inky_display.set_image(most_recent_frame)
self.inky_display.show()
time.sleep(0.1)
def main():
inky_display = InkyPHAT("black")
inky_display.set_border(inky_display.WHITE)
config = importconfig()
if config['showtime'] == "True":
showtime = True
else:
showtime = False
#Need to work out the config mode
if len(config["stops"]) > 1:
multistops(config, showtime, inky_display)
else:
stops = config["stops"][0]
singlestop(stops, showtime, inky_display)
def draw_to_display():
# Set up properties of eInk display
inky_display = InkyPHAT("red")
inky_display.set_border(inky_display.BLACK)
# Load previously generated image
img = draw_semester_display()
# Display generated semester progress image
inky_display.set_image(img)
inky_display.show()
class MagicBoxScreen():
def __init__(self):
self._inky = InkyPHAT("black")
self._font = ImageFont.truetype(FredokaOne, 16)
def displayMessage(self, message: str="No Message"):
w, h = self._font.getsize(message)
x = (self._inky.WIDTH / 2) - (w / 2)
y = (self._inky.HEIGHT / 2) - (h / 2)
img = Image.new("P", (self._inky.WIDTH, self._inky.HEIGHT))
draw = ImageDraw.Draw(img)
draw.text((x, y), message, self._inky.BLACK, self._font)
self._inky.set_image(img)
self._inky.show()
def displayQuestion(self, \
questionText: str="What is the speed of light?", \
answerText: List[str] = \
['0 m/s', '100 m/s', '1 km/s', '3,000 km/s', '300,000 km/s']):
def presentOnInkyScreen(image):
logging.info("Loading View onto Inky Phat.")
from inky import InkyPHAT
#Test invert image.
image = image.convert('L')
image = ImageOps.invert(image)
image = image.convert('1')
# Set up the display
inky_display = InkyPHAT("black")
#inky_display.set_border(inky_display.BLACK)
inky_display.v_flip = True
inky_display.h_flip = True
# Display
inky_display.set_border("black")
inky_display.set_image(image)
inky_display.show()
logging.info("View Sent to Device Successfully")
def run():
inky_display = InkyPHAT(COLOR)
# inky_display.set_rotation(180)
inky_display.set_border(InkyPHAT.RED)
img = Image.new("P", (InkyPHAT.WIDTH, InkyPHAT.HEIGHT))
palletize(img)
image_draw = ImageDraw.Draw(img)
if DEBUG:
# Draw vertical line
for y in xrange(InkyPHAT.HEIGHT):
img.putpixel((InkyPHAT.WIDTH / 2, y), inky_display.RED)
img.putpixel((InkyPHAT.WIDTH / 4, y), inky_display.RED)
# Draw horizontal line
for x in xrange(InkyPHAT.WIDTH):
img.putpixel((x, InkyPHAT.HEIGHT / 2), inky_display.RED)
weather = Weather(location_coords)
if weather.is_same_as_temp_data():
if DEBUG:
print("Not updating the display since the forecast is the same as last time")
weather.save_temp_forecast(only_if_no_such_file=True)
return
else:
if DEBUG:
print("Updating display since the forecast has changed since the last render")
weather.save_temp_forecast()
draw_text(image_draw, 2, "UV", "l")
draw_text(image_draw, 2, weather.uv_index, "r",
color=InkyPHAT.RED if weather.is_uv_warning() else InkyPHAT.BLACK)
draw_text(image_draw, 1, get_high_temp_copy(weather), "c")
draw_text(image_draw, 4, get_low_temp_copy(weather), "c")
if weather.precipitation_is_likely():
precip_chance_str = str(int(round(weather.current_precip_probability * 100))) + "%"
draw_text(image_draw, 3, get_sky_icon(weather), "l", is_icon=True)
draw_text(image_draw, 3, precip_chance_str, "r", is_icon=False)
else:
draw_text(image_draw, 3, get_sky_icon(weather), "c", is_icon=True)
inky_display.set_image(img)
inky_display.show()
if DEBUG:
print(weather.eink_data_string())
def updateeink(issdetails, mapdot, trail):
"""update location text and map to the e-ink screen"""
issx = int(mapdot[0])
issy = int(mapdot[1])
inky_display = InkyPHAT("yellow")
palette = [255, 255, 255, 0, 0, 0, 255, 0, 0]
font10 = ImageFont.truetype('/home/pi/isstracker/FreeSans.ttf', 10)
font14 = ImageFont.truetype('/home/pi/isstracker/FreeSans.ttf', 14)
font16 = ImageFont.truetype('/home/pi/isstracker/FreeSans.ttf', 16)
font18 = ImageFont.truetype('/home/pi/isstracker/FreeSans.ttf', 18)
im = Image.open('/home/pi/isstracker/small-world-map.png')
d = ImageDraw.ImageDraw(im)
taille_pt = 3
isspos = (int(mapdot[0]) - taille_pt, int(mapdot[1]) - taille_pt,
int(mapdot[0]) + taille_pt, int(mapdot[1]) + taille_pt)
d.ellipse(isspos, fill=2)
for item in point2ellipse(trail, 1):
d.ellipse(item, fill=2)
d.text((3, 80),
'à ' + str(round(issdetails[2])) + ' Km de ' + issdetails[1] +
' (' + issdetails[0] + ')',
font=font18,
fill=2)
from uptime import uptime
uptime = round(uptime() / 60, 1)
d.text((0, 70), "ut : " + str(uptime) + " min", font=font10, fill=1)
inky_display.set_image(im)
inky_display.show()
class InkyDriver:
def __init__(self):
self.inky = InkyPHAT('yellow')
def create_new_image(self, countries_cases):
current_height = 0
# inky_display.set_rotation(180)
self.inky.set_border(self.inky.RED)
# Create a new canvas to draw on
img = Image.new("P", (self.inky.WIDTH, self.inky.HEIGHT))
draw = ImageDraw.Draw(img)
# Load the fonts
font = ImageFont.truetype(HankenGroteskBold, 20)
# Calculate the positioning and draw the text
for countryCases in countries_cases:
text = str(countryCases[0]) + ": " + str(countryCases[1])
width, height = font.getsize(text)
center = int((self.inky.WIDTH - width) / 2)
draw.text((center, current_height),
text,
self.inky.BLACK,
font=font)
current_height += height
# Display the completed picture
self.inky.set_image(img)
self.inky.show()
def _init_display(self):
if self._is_inky():
logging.info("initializing inky display")
from inky import InkyPHAT
self._display = InkyPHAT(self._display_color)
self._display.set_border(InkyPHAT.BLACK)
self._render_cb = self._inky_render
elif self._is_papirus():
logging.info("initializing papirus display")
from pwnagotchi.ui.papirus.epd import EPD
os.environ['EPD_SIZE'] = '2.0'
self._display = EPD()
self._display.clear()
self._render_cb = self._papirus_render
elif self._is_waveshare_v1():
if self._display_color == 'black':
logging.info(
"initializing waveshare v1 display in monochromatic mode")
from pwnagotchi.ui.waveshare.v1.epd2in13 import EPD
self._display = EPD()
self._display.init(self._display.lut_full_update)
self._display.Clear(0xFF)
self._display.init(self._display.lut_partial_update)
self._render_cb = self._waveshare_render
else:
logging.info("initializing waveshare v1 display 3-color mode")
from pwnagotchi.ui.waveshare.v1.epd2in13bc import EPD
self._display = EPD()
self._display.init()
self._display.Clear()
self._render_cb = self._waveshare_bc_render
elif self._is_waveshare_v2():
logging.info("initializing waveshare v2 display")
from pwnagotchi.ui.waveshare.v2.waveshare import EPD
self._display = EPD()
self._display.init(self._display.FULL_UPDATE)
self._display.Clear(WHITE)
self._display.init(self._display.PART_UPDATE)
self._render_cb = self._waveshare_render
else:
logging.critical("unknown display type %s" % self._display_type)
plugins.on('display_setup', self._display)
self.on_render(self._on_view_rendered)
def __init__(self, font):
"""
Constructor
"""
self.__font = font
self.__device = InkyPHAT(self.COLOUR)
self.__image = Image.new("P",
(self.__device.WIDTH, self.__device.HEIGHT))
self.__drawing = ImageDraw.Draw(self.__image)
m_width, m_height = self.__font.getsize("M")
self.__text_width = self.__device.WIDTH // m_width
self.__text_height = self.__device.HEIGHT // m_height + 1
self.__stop = None
self.__render_timeout = Timeout(self.DRAW_TIME)
# self.__spi = SPI(self.__SPI_BUS, self.__SPI_DEVICE, None, None)
self.__spi = SPI(self.__SPI_BUS, self.__SPI_DEVICE, self.__SPI_MODE,
self.__SPI_CLOCK)
def draw_display_message(text: str):
# Set up properties of eInk display
inky_display = InkyPHAT("red")
inky_display.set_border(inky_display.BLACK)
hanked_medium = ImageFont.truetype(HankenGroteskMedium, 20)
img = Image.new("P", size=(InkyPHAT.WIDTH, InkyPHAT.HEIGHT))
draw = ImageDraw.Draw(img)
text_w, text_h = hanked_medium.getsize(text)
text_x = (InkyPHAT.WIDTH - text_w) // 2
text_y = (InkyPHAT.HEIGHT - text_h) // 2
draw.text((text_x, text_y), text, InkyPHAT.BLACK, font=hanked_medium)
inky_display.set_image(img)
inky_display.show()
def refreshDisplay(intervall, priority, scheduler):
logging.info("Refresh Display - start")
lastValue = readLastValue()
avgMonth = readAvgFromDays(31)
avgYear = readAvgFromDays(365)
inkyDisplay = InkyPHAT(colour)
inkyDisplay.set_border(inkyDisplay.BLACK)
# Load our background image
img = Image.open("/var/local/cellarsense/cellarsense-background.png")
draw = ImageDraw.Draw(img)
mainHeaderFont = ImageFont.truetype("FreeMonoBold.ttf", 20)
mainFont = ImageFont.truetype("FreeMono.ttf", 20)
medianFont = ImageFont.truetype("FreeMono.ttf", 15)
lastValuePrint = "{:4.1f}°C {:4.1f}%".format(lastValue["temperature"],
lastValue["humidity"])
avgMonthPrint = "øm {:4.1f}°C {:4.1f}%".format(avgMonth["temperature"],
avgMonth["humidity"])
avgYearPrint = "øa {:4.1f}°C {:4.1f}%".format(avgYear["temperature"],
avgYear["humidity"])
logging.debug("Refresh Display - %s", lastValuePrint)
logging.debug("Refresh Display - %s", avgMonthPrint)
logging.debug("Refresh Display - %s", avgYearPrint)
draw.text((5, 5),
"CellarSense",
fill=inkyDisplay.BLACK,
font=mainHeaderFont)
draw.text((20, 35), lastValuePrint, fill=inkyDisplay.BLACK, font=mainFont)
draw.text((10, 70), avgMonthPrint, fill=inkyDisplay.BLACK, font=medianFont)
draw.text((10, 85), avgYearPrint, fill=inkyDisplay.BLACK, font=medianFont)
inkyDisplay.set_image(img)
inkyDisplay.show()
logging.info("Refresh Display - done")
# reschedule
scheduler.enter(intervall, priority, refreshDisplay,
(intervall, priority, scheduler))
def _init_display(self, color: str, mock=False, display_type='phat'):
if mock:
from inky import InkyMockPHAT as InkyPHAT
from inky import InkyMockWHAT as InkyWHAT
else:
from inky import InkyPHAT
from inky import InkyWHAT
if display_type == 'phat':
self._display = InkyPHAT(color)
self._scale_size = 1.0
self._padding = 2
elif display_type == 'what':
self._display = InkyWHAT(color)
self._scale_size = 2.20
self._padding = 15
self._display.set_border(self._display.BLACK)
def my_draw(message):
inky_display = InkyPHAT("black")
inky_display.set_border(inky_display.WHITE)
img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT))
draw = ImageDraw.Draw(img)
font = ImageFont.truetype(FredokaOne, 30)
w, h = font.getsize(message)
#x = (inky_display.WIDTH / 2) - (w / 2)
#y = (inky_display.HEIGHT / 2) - (h / 2)
x = 1
y = 1
draw.text((x, y), message, inky_display.BLACK, font)
inky_display.set_image(img)
inky_display.show()
def print_text(text):
"""Displays text in Inky pHAT display.
Args:
text: String that is displayed on the Inky pHAT
"""
inky_display = InkyPHAT("black")
inky_display.set_border(inky_display.WHITE)
img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT))
draw = ImageDraw.Draw(img)
font = ImageFont.truetype(FredokaOne, 30)
message = text
width, height = font.getsize(message)
x_axis = (inky_display.WIDTH / 2) - (width / 2)
y_axis = (inky_display.HEIGHT / 2) - (height / 2)
draw.text((x_axis, y_axis), message, inky_display.BLACK, font)
inky_display.set_image(img)
inky_display.show()
