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()
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 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()
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()
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 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 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 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()
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 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 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")
class Clock(): 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 create_image(self, currenttime, currentdate, temp, tempmax, tempmin): img = Image.open("./images/backdrop.png") draw = ImageDraw.Draw(img) #Adding the time and date font = ImageFont.truetype(FredokaOne, 28) draw.text((6, 15), currentdate, self.RED, font=font) font = ImageFont.truetype(FredokaOne, 40) draw.text((int(self.WIDTH / 2), 5), currenttime, self.BLACK, font=font) #adding max temp font = ImageFont.truetype(FredokaOne, 20) draw.text((22, 70), temp, self.RED, font=font) draw.text((92, 70), tempmin, self.RED, font=font) draw.text((160, 70), tempmax, self.RED, font=font) self.display_img(img) def display_img(self, img): img = img.rotate(self.rotation) self.inky_display.set_image(img) self.inky_display.show() def test_image(self): img = Image.open("./images/TagTest-212x104.png") self.display_img(img)
type=str, required=True, choices=["red", "black", "yellow"], help="ePaper display colour") args = parser.parse_args() colour = args.colour # Set up the correct display and scaling factors if args.type == "phat": inky_display = InkyPHAT(colour) elif args.type == "what": inky_display = InkyWHAT(colour) inky_display.set_border(inky_display.BLACK) # Pick the correct logo image to show depending on display type/colour if args.type == "phat": if colour == 'black': img = Image.open( os.path.join(PATH, "phat/resources/InkypHAT-212x104-bw.png")) else: img = Image.open( os.path.join(PATH, "phat/resources/InkypHAT-212x104.png")) elif args.type == "what": if colour == 'black': img = Image.open( os.path.join(PATH, "what/resources/InkywHAT-400x300-bw.png")) else:
class PzWeather(): 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 change_screen(self, screen_name): logger.debug('PzWeather::change_screen \t' + screen_name) self.make_current_screen(self.screens[screen_name]) def make_current_screen(self, screen): logger.debug('PzWeather::make_current_screen \t' + screen.name) if self.current: self.last = self.current self.current = screen self.render_current_screen() def render_current_screen(self): if self.current is not None: self.current.render(bg=self.bg.copy(), darksky=self.darksky, noaa=self.noaa, icon=args.icon) # do time check to update data def check_time(self): now = datetime.now() tdiff = now - self.last_load if (tdiff >= timedelta(minutes=10)): self.load_data() self.render_current_screen() def load_data(self): logger.debug('PzWeather::load_data') self.bg = SatelliteImage(args.dither, args.threshold, debug=self.debug).image self.noaa = NoaaForecast(debug=self.debug).forecast self.darksky = DarkSkyWeather(debug=self.debug).weather logger.debug(self.noaa) logger.debug(self.darksky) self.last_load = datetime.now() def toggle_screens(self): logger.debug('PzWeather::toggle_screens') if self.current and self.current.name == 'current_weather': self.change_screen('forecast_days') return self.change_screen('current_weather') def button_toggle(self): self.btn_down = not self.btn_down logger.info('PzWeather::button_toggle {}'.format(self.btn_down)) if self.btn_down: pass else: self.toggle_screens() # helper to exit program in case we need special rpi consideration in future def kill(self): if pzwglobals.RUN_ON_RASPBERRY_PI: sys.exit(0) else: sys.exit(0)
action="store_true", default=False, help="Clear the ePaper display and exit.") args = parser.parse_args() if args.do_clear: print("clearing the display ...") with open(args.config, 'rt') as fp: config = yaml.safe_load(fp) cleardisplay = config['ui']['display']['type'] if cleardisplay in ('inkyphat', 'inky'): print("inky display") from inky import InkyPHAT epd = InkyPHAT(config['ui']['display']['color']) epd.set_border(InkyPHAT.BLACK) self._render_cb = self._inky_render elif cleardisplay in ('papirus', 'papi'): print("papirus display") from pwnagotchi.ui.papirus.epd import EPD os.environ['EPD_SIZE'] = '2.0' epd = EPD() epd.clear() elif cleardisplay in ('waveshare_1', 'ws_1', 'waveshare1', 'ws1'): print("waveshare v1 display") from pwnagotchi.ui.waveshare.v1.epd2in13 import EPD epd = EPD() epd.init(epd.lut_full_update) epd.Clear(0xFF) elif cleardisplay in ('waveshare_2', 'ws_2', 'waveshare2', 'ws2'): print("waveshare v2 display")
def main(): # yyyy-mm-dd hh:mm:ss currenttime = strftime("%Y-%m-%d %H:%M:%S", gmtime()) # Write text with weather values to the canvas inkydatetime = strftime("%d/%m %H:%M") # IoT Host Name host = os.uname()[1] # - start timing starttime = datetime.datetime.now().strftime('%m/%d/%Y %H:%M:%S') start = time.time() # Ip address ipaddress = minifiutil.IP_address() parser = argparse.ArgumentParser() parser.add_argument('--price', help='price to be recognized.', required=True) args = parser.parse_args() # end of processing end = time.time() # Output JSON row = {} uuid2 = '{0}_{1}'.format(strftime("%Y%m%d%H%M%S", gmtime()), uuid.uuid4()) cpuTemp = int(float(minifiutil.getCPUtemperature())) usage = psutil.disk_usage("/") # Format Fields row['host'] = os.uname()[1] row['cputemp'] = str(round(cpuTemp, 2)) row['ipaddress'] = str(ipaddress) row['endtime'] = '{0:.2f}'.format(end) row['runtime'] = '{0:.2f}'.format(end - start) row['systemtime'] = datetime.datetime.now().strftime('%m/%d/%Y %H:%M:%S') row['starttime'] = str(starttime) row['diskfree'] = "{:.1f}".format(float(usage.free) / 1024 / 1024) row['memory'] = str(psutil.virtual_memory().percent) row['uuid'] = str(uuid2) row['price'] = str(args.price) # Output JSON json_string = json.dumps(row) print(json_string) # Set up the display inky_display = InkyPHAT("red") inky_display.set_border(inky_display.BLACK) # Create a new canvas to draw on # 212x104 img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT)) draw = ImageDraw.Draw(img) # Load the FredokaOne font font = ImageFont.truetype(FredokaOne, 22) # draw data draw.text((0, 0), "{}".format('Cloudera Mug'), inky_display.BLACK, font=font) draw.text((0, 32), "Price: $ {}".format(args.price), inky_display.RED, font=font) # Display the data on Inky pHAT inky_display.set_image(img) inky_display.show()
########################################################## ### Draw images on the inky display ########################################################## from inky import InkyPHAT inky_display = InkyPHAT(inky_color) # Use BLACK or RED depending on positive or negative change_percent if '-' in change_percent: text_color = inky_display.RED plus_sign = "" # number already has minus sign (-) else: text_color = inky_display.BLACK plus_sign = "+" # Add plus sign (+) to positive number inky_display.set_border(text_color) change_percent = plus_sign + change_percent + "%" from PIL import Image, ImageFont, ImageDraw img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT)) draw = ImageDraw.Draw(img) from fonts.ttf import FredokaOne def draw_price(): font = ImageFont.truetype(FredokaOne, 36) message = price w, h = font.getsize(message) x = (inky_display.WIDTH / 2) - (w / 2)
class InkyDevice(): 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 startup(self): print('writing startup image...') with self.lock: img = Image.open("resources/k8s-bw.png") draw = ImageDraw.Draw(img) self.display.set_image(img) self.display.show() def shutdown(self): print('writing shutdown image...') with self.lock: img = Image.open("resources/8-bit-dino.png") draw = ImageDraw.Draw(img) font = ImageFont.truetype('resources/Eden_Mills_Bold.ttf', 28) message = "offline " message_width, message_height = self.get_text_size(message, font) x, y = Location.CenterRight.place(message, font, message_width, message_height, self.display.WIDTH, self.display.HEIGHT) draw.text((x, y), message, self.display.BLACK, font) self.display.set_image(img) self.display.show() def get_text_size(self, message, font): # render the text in another text buffer to get the dimensions message_width, message_height = 0,0 for line in message.split("\n"): partial_width, partial_height = font.getsize(line) message_width = max(message_width, partial_width) approx_line_spacing = 1.2 message_height += int(partial_height*approx_line_spacing) return message_width, message_height def write(self, render_result): with self.lock: img = Image.new("P", (self.display.WIDTH, self.display.HEIGHT)) draw = ImageDraw.Draw(img) for location, message in render_result.items(): # render the text in another text buffer to get the dimensions message_width, message_height = self.get_text_size(message, self.font) # find the placement of the text buffer and overlay onto the screen buffer x, y = location.place(message, self.font, message_width, message_height, self.display.WIDTH, self.display.HEIGHT) draw.text((x, y), message, self.display.BLACK, self.font) # flush the screen buffer to the device self.display.set_image(img) self.display.show()
if args.number: cycles = args.number else: cycles = 3 colours = (inky_display.RED, inky_display.BLACK, inky_display.WHITE) colour_names = (colour, "black", "white") # Create a new canvas to draw on img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT)) # Loop through the specified number of cycles and completely # fill the display with each colour in turn. for i in range(cycles): print("Cleaning cycle %i\n" % (i + 1)) for j, c in enumerate(colours): print("- updating with %s" % colour_names[j]) inky_display.set_border(c) for x in range(inky_display.WIDTH): for y in range(inky_display.HEIGHT): img.putpixel((x, y), c) inky_display.set_image(img) inky_display.show() time.sleep(1) print("\n") print("Cleaning complete!")
import lib.epd2in13_V2 display = lib.epd2in13_V2.EPD() display.init(display.FULL_UPDATE) display.Clear(0xFF) # These are the opposite of what InkyPhat uses. WIDTH = display.height # yes, Height HEIGHT = display.width # yes, width img = Image.new('1', (WIDTH, HEIGHT), 255) BLACK = "black" else: logging.info("Display type: InkyPHAT") from inky import InkyPHAT display = InkyPHAT("black") display.set_border(display.WHITE) WIDTH = display.WIDTH HEIGHT = display.HEIGHT img = Image.new("P", (display.WIDTH, display.HEIGHT)) BLACK = display.BLACK logging.info("Display dimensions: W %s x H %s", WIDTH, HEIGHT) draw = ImageDraw.Draw(img) font_size = 37 if "FONT_SIZE" in os.environ: font_size = int(os.environ["FONT_SIZE"]) # Use a dashboard defined message if we have one, otherwise load a nice quote if "INKY_MESSAGE" in os.environ:
class draw_words(): 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 cls(self): img = Image.new("P", (self.d.WIDTH, self.d.HEIGHT)) draw = ImageDraw.Draw(img) draw.rectangle([0, 0, self.d.WIDTH, self.d.HEIGHT], fill=self.d.BLACK) self.d.set_image(img) self.d.show() def draw_list(self, key_code): img = Image.new("P", (self.d.WIDTH, self.d.HEIGHT)) draw = ImageDraw.Draw(img) # Start by filling the screen with a black fill... draw.rectangle([0, 0, self.d.WIDTH, self.d.HEIGHT], fill=self.d.BLACK) int_value = int(key_code, 16) bits_list = [] mask = 0x1FFF for i in range(9): bits_list.append((int_value >> (13 * i)) & mask) bits_list.append(int_value >> 117) # Now we have the word list - we need to pad the final block to 13-bits... bits_list[9] = bits_list[9] << 2 words = [] for block in bits_list: words.append(self.word_list[block]) i = 0 l_col = True for word in words: y = (22 * (i + 1)) - 3 #2 draw.line((0, y, self.d.WIDTH, y), self.d.RED, 2) if l_col: draw.text((5, (i * 22) - 2), word.upper(), self.d.WHITE, self.font) else: draw.text((110, (i * 22) - 2), word.upper(), self.d.WHITE, self.font) i += 1 l_col = not (l_col) draw.line((0, 0, 0, self.d.HEIGHT), self.d.RED, 2) draw.line((self.d.WIDTH / 2, 0, self.d.WIDTH / 2, self.d.HEIGHT), self.d.RED, 2) draw.line((self.d.WIDTH - 2, 0, self.d.WIDTH - 2, self.d.HEIGHT), self.d.RED, 2) self.d.set_image(img) self.d.show()
if len(sys.argv) > 1: INKY_COLOUR = sys.argv[1] if INKY_COLOUR not in ['red', 'yellow', 'black']: print("Usage: {} <red, yellow, black>".format(sys.argv[0])) sys.exit(1) phat = InkyPHAT(INKY_COLOUR) white = Image.new('P', (212, 104), phat.WHITE) black = Image.new('P', (212, 104), phat.BLACK) while True: print("White") phat.set_border(phat.WHITE) phat.set_image(black) phat.show() time.sleep(1) if INKY_COLOUR == 'red': print("Red") phat.set_border(phat.RED) phat.set_image(white) phat.show() time.sleep(1) if INKY_COLOUR == 'yellow': print("Yellow") phat.set_border(phat.YELLOW) phat.set_image(white)
from inky import InkyPHAT from PIL import Image # valid colors are red, yellow and black inky_display = InkyPHAT("black") inky_display.set_border(InkyPHAT.WHITE) img = Image.open("/home/pi/src/superporgs/superporgs8.png") inky_display.set_image(img) inky_display.show()
colour = args.colour # Set up the correct display and scaling factors if args.type == "phat": inky_display = InkyPHAT(colour) scale_size = 1 padding = 0 elif args.type == "what": inky_display = InkyWHAT(colour) scale_size = 2.20 padding = 15 # inky_display.set_rotation(180) inky_display.set_border(inky_display.RED) # Create a new canvas to draw on img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT)) draw = ImageDraw.Draw(img) # Load the fonts fredoka_font = ImageFont.truetype(FredokaOne, int(30 * scale_size)) hanken_bold_font = ImageFont.truetype(HankenGroteskMedium, int(14 * scale_size)) hanken_medium_font = ImageFont.truetype(HankenGroteskBold, int(30 * scale_size)) # Grab the text to be displayed
class Inky(DisplayImpl): def __init__(self, config): super(Inky, self).__init__(config, 'inky') self._display = None def layout(self): fonts.setup(10, 8, 10, 28, 25, 9) self._layout['width'] = 212 self._layout['height'] = 104 self._layout['face'] = (0, 37) self._layout['name'] = (5, 18) self._layout['channel'] = (0, 0) self._layout['aps'] = (30, 0) self._layout['uptime'] = (147, 0) self._layout['line1'] = [0, 12, 212, 12] self._layout['line2'] = [0, 92, 212, 92] self._layout['friend_face'] = (0, 76) self._layout['friend_name'] = (40, 78) self._layout['shakes'] = (0, 93) self._layout['mode'] = (187, 93) self._layout['status'] = { 'pos': (102, 18), 'font': fonts.status_font(fonts.Small), 'max': 20 } return self._layout 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) elif self.config['color'] == 'auto': from inky.auto import auto self._display = auto() self._display.set_border(self._display.BLACK) self._layout['width'] = self._display.WIDTH self._layout['height'] = self._display.HEIGHT else: from inky import InkyPHAT self._display = InkyPHAT(self.config['color']) self._display.set_border(InkyPHAT.BLACK) def render(self, canvas): if self.config['color'] == 'black' or self.config[ 'color'] == 'fastAndFurious': display_colors = 2 else: display_colors = 3 img_buffer = canvas.convert('RGB').convert('P', palette=1, colors=display_colors) if self.config['color'] == 'red': img_buffer.putpalette([ 255, 255, 255, # index 0 is white 0, 0, 0, # index 1 is black 255, 0, 0 # index 2 is red ]) elif self.config['color'] == 'yellow': img_buffer.putpalette([ 255, 255, 255, # index 0 is white 0, 0, 0, # index 1 is black 255, 255, 0 # index 2 is yellow ]) else: img_buffer.putpalette([ 255, 255, 255, # index 0 is white 0, 0, 0 # index 1 is black ]) self._display.set_image(img_buffer) try: self._display.show() except: logging.exception("error while rendering on inky") def clear(self): self._display.Clear()
dto = datetime.fromisoformat(dt).astimezone(pytz.timezone("Europe/London")) return dto.strftime("%A {}, %H:%M".format(date_suffixed(dto.strftime("%d")))) def format_temperature(t): return "{}˚C".format(t) def format_humidity(h): return "{}%".format(h) def sample_hygrometer(device): dt = datetime.now(tz=timezone.utc) (t,h) = device.readSensor() return (dt.isoformat(timespec='seconds'), t, h) phat = InkyPHAT("red") phat.set_border(phat.WHITE) phat.h_flip = True phat.v_flip = True img = Image.new("P", (phat.WIDTH, phat.HEIGHT)) draw = ImageDraw.Draw(img) smallFont = ImageFont.truetype("04B_03__.ttf", 8) mediumFont = ImageFont.truetype(FredokaOne, 16) largeFont = ImageFont.truetype(FredokaOne, 32) am2320 = AM2320(args.i2c) (sensor_dt, sensor_t, sensor_h) = sample_hygrometer(am2320) dt = format_datetime(sensor_dt) t = format_temperature(sensor_t)
from inky import InkyPHAT from PIL import Image, ImageFont, ImageDraw from font_fredoka_one import FredokaOne # get inky display variable inky_display = InkyPHAT("yellow") # set inky display border (YELLOW/BLACK/WHITE) inky_display.set_border(inky_display.YELLOW) img = Image.new("P", (inky_display.WIDTH, inky_display.HEIGHT)) draw = ImageDraw.Draw(img) # decide font and size font = ImageFont.truetype(FredokaOne, 32) # message to write message = "Hello, World!" # get width and height of the message to write w, h = font.getsize(message) # The x and y variables will tell the draw.text() function where to place the top left corner of our text x = (inky_display.WIDTH / 2) - (w / 2) y = (inky_display.HEIGHT / 2) - (h / 2) # draw message at a starting point, with decided font and colour draw.text((x, y), message, inky_display.YELLOW, font) inky_display.set_image(img) inky_display.show()
# code taken from tutorial at https://learn.pimoroni.com/tutorial/sandyj/getting-started-with-inky-phat # John Harney, 1.17.2020 from inky import InkyPHAT from PIL import Image, ImageFont, ImageDraw from font_fredoka_one import FredokaOne inky_display = InkyPHAT("yellow") 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, 22) message = "Centre College" w, h = font.getsize(message) x = (inky_display.WIDTH / 2) - (w / 2) y = (inky_display.HEIGHT / 2) - (h / 2) draw.text((x, y), message, inky_display.YELLOW, font) inky_display.set_image(img) inky_display.show()
def set_inky_display(image): inky_display = InkyPHAT(display_colour) inky_display.set_image(image) inky_border = inky_display.WHITE if border_colour == 'white' else inky_display.BLACK inky_display.set_border(inky_border) inky_display.show()