def draw_circle(self, x, y, r, c, fill=False, gradient=None): if not isinstance(c, graphics.Color): c = graphics.Color(c[0], c[1], c[2]) if fill: for radius in range(r): if gradient is not None: red, green, blue = self.__gradient(gradient, x, r, c) c.red, c.green, c.blue = red, green, blue graphics.DrawCircle(self.matrix, x, y, radius, c) else: graphics.DrawCircle(self.matrix, x, y, r, c)
def render_everything(can): can.Clear() len = graphics.DrawText(can, font, can.width - 12, 11, white_color, str(timer_number)) render_pick_ups(can) graphics.DrawCircle(can, player_x, player_y, 0, blue_color) can = matrix.SwapOnVSync(can)
def drawDayNight(self, centerX, centerY, isDay): dayNightColour = Colours.Black squareSize=6 if isDay == 1: dayNightColour = Colours.Yellow else: dayNightColour = Colours.Gray self.drawDataBoarder(centerX, centerY, squareSize, dispColour=dayNightColour, drawRight=True) graphics.DrawLine(self.offscreen_canvas, centerX - 1, centerY - 1, centerX + 1, centerY + 1, dayNightColour) graphics.DrawLine(self.offscreen_canvas, centerX - 1, centerY + 1, centerX + 1, centerY - 1, dayNightColour) for r in range(0, 3): graphics.DrawCircle(self.offscreen_canvas, centerX, centerY, r, dayNightColour) if isDay == 1: # Sun twinkles twinkleSize=4 self.__animSunStep += 5 start = 0 - self.__animSunStep end = 359 - self.__animSunStep if start < -359: self.__animSunStep = 0 start = 0 end = 359 for twinkle in range(start, end, int(360/8)): sinMultR = math.sin(math.radians(twinkle)) cosMultR = math.cos(math.radians(twinkle)) graphics.DrawLine(self.offscreen_canvas, centerX + (twinkleSize * sinMultR), centerY + (twinkleSize * cosMultR), centerX + (twinkleSize * sinMultR), centerY + (twinkleSize * cosMultR), Colours.Yellow)
def loop(self): previous_head = Point() previous_head.x = self.head.x previous_head.y = self.head.y previous_head_temp = Point() ## head logic if self.update_time: self.follow(self.ball) else: self.follow(self.fake_ball) for t in self.tail: previous_head_temp.x = t.x previous_head_temp.y = t.y t.x = previous_head.x t.y = previous_head.y previous_head.x = previous_head_temp.x previous_head.y = previous_head_temp.y # Drawing self.canvas.Clear() #graphics.DrawLine(canvas, 5, 5, 22, 13, red) graphics.DrawCircle(self.canvas, self.head.x, self.head.y, 0, self.red) for c, t in enumerate(self.tail): color = max(50, 255-30*c) self.matrix.SetPixel(t.x,t.y, color, 0, 0) graphics.DrawCircle(self.canvas, self.ball.x, self.ball.y, 0, self.white) #graphics.DrawCircle(self.canvas, self.fake_ball.x, self.fake_ball.y, 0, self.green) str_time = "{} {}".format( str(self.hour).zfill(2), str(self.minute).zfill(2)) graphics.DrawText(self.canvas, self.font, 7, 5, self.blue, str_time) # Change time if self.minute != datetime.now().minute or self.hour != datetime.now().hour: self.update_time = True time.sleep(0.1) # show display for 10 seconds before exit self.canvas = self.matrix.SwapOnVSync(self.canvas)
def loop(self): self.image.thumbnail((self.matrix.width, self.matrix.height), Image.ANTIALIAS) self.matrix.SetImage(self.image.convert('RGB')) graphics.DrawText(self.matrix, self.font, 20, 8, self.white, self.temperature) graphics.DrawCircle(self.matrix, 29, 4, 1, self.white) time.sleep(0.1)
def drawHand(angle, length, color, line=True): #Offset by 90.0 degrees so that we get 0 as the top of the clock, #not 3 o'clock, like algebra normally does angle -= 90.0 rads = math.radians(angle) center = self.centerPoint() endPoint = center.offsetByVector(rads, length) if line: graphics.DrawLine(offscreen_canvas, center.x, center.y, endPoint.x, endPoint.y, color) else: graphics.DrawCircle(offscreen_canvas, endPoint.x, endPoint.y, 1, color)
def run(self): canvas = self.matrix font = graphics.Font() font.LoadFont("../../../fonts/nanum.bdf") red = graphics.Color(255, 0, 0) graphics.DrawLine(canvas, 5, 5, 22, 13, red) green = graphics.Color(0, 255, 0) graphics.DrawCircle(canvas, 15, 15, 10, green) blue = graphics.Color(0, 0, 255) graphics.DrawText(canvas, font, 2, 10, blue, "Text") time.sleep(10) # show display for 10 seconds before exit
def draw_ok(self, name: str): canvas = self.canvas start_headline = self.calc_horizontal_center(len(name), 4, 0, self.display.matrix.width) graphics.DrawText(self.canvas, self.font_ok, start_headline, 8, self.font_ok_color, name) graphics.DrawCircle(self.canvas, 32, 20, 10, self.circle_ok_color) x_pos = 27 y_pos = 21 for i in range(0, 4): canvas.SetPixel(x_pos + i, y_pos + i, 255, 255, 255) x_pos = 31 y_pos = 25 for i in range(0, 9): canvas.SetPixel(x_pos +i, y_pos - i, 255, 255, 255)
def timer(can): global timer_number global win while True: can.Clear() len = graphics.DrawText(can, font, can.width - 12, 11, white_color, str(timer_number)) render_pick_ups(can) graphics.DrawCircle(can, player_x, player_y, 0, blue_color) can = matrix.SwapOnVSync(can) time.sleep(1) timer_number -= 1 if (timer_number <= 0): break if (win == True): break
def draw_error(self, name: str): canvas = self.canvas graphics.DrawCircle(self.canvas, 12, 16, 10, self.circle_error_color) x_pos = 8 y_pos = 20 for i in range(0, 9): canvas.SetPixel(x_pos + i, y_pos - i, 255, 255, 255) x_pos = 8 y_pos = 12 for i in range(0, 9): canvas.SetPixel(x_pos +i, y_pos + i, 255, 255, 255) graphics.DrawText(self.canvas, self.font_error, 26, 14, self.font_error_color, 'FAILED ON') graphics.DrawText(self.canvas, self.font_info, 26, 24, self.font_info_color, name)
def show_home_weather(self): time.sleep(0.01) self.canvas = self.matrix.SwapOnVSync(self.canvas) self.canvas.Clear() self.home_image.thumbnail((self.matrix.width, self.matrix.height), Image.ANTIALIAS) self.matrix.SetImage(self.home_image.convert('RGB'), 0, 7) home_temperature = r.get('temperature').decode("utf-8").split('.')[0] home_humidity = r.get('humidity').decode("utf-8").split('.')[0] graphics.DrawText(self.matrix, self.font, 9, 13, self.yellow, home_temperature) graphics.DrawCircle(self.matrix, 18, 9, 1, self.yellow) graphics.DrawText(self.matrix, self.font, 21, 13, self.blue, "{}%".format(home_humidity)) str_time = "{}:{}".format( str(self.hour).zfill(2), str(self.minute).zfill(2)) graphics.DrawText(self.matrix, self.font, 7, 5, self.blue, str_time) time.sleep(5)
def windDirection(self, centerX, centerY, windPointer, windSpeed, handLength, handColour): circleRadius = 5 arrowHeadSize = 10 windPointer = float(windPointer) windPointerR = math.radians(windPointer) sinMult = math.sin(windPointerR) cosMult = math.cos(windPointerR) graphics.DrawCircle(self.offscreen_canvas, centerX, centerY, circleRadius, handColour) graphics.DrawLine(self.offscreen_canvas, centerX + ((sinMult * circleRadius) * 1.1), centerY - ((cosMult * circleRadius) * 1.1), centerX + (sinMult * handLength), centerY - (cosMult * handLength), handColour) # Left headAngle = windPointer - arrowHeadSize if headAngle > 360: headAngle += 360 sinMultL = math.sin(math.radians(headAngle)) cosMultL = math.cos(math.radians(headAngle)) graphics.DrawLine(self.offscreen_canvas, centerX + (sinMultL * (handLength - 1)), centerY - (cosMultL * (handLength - 1)), centerX + (sinMult * handLength), centerY - (cosMult * handLength), handColour) # Right headAngle = windPointer + arrowHeadSize if headAngle > 360: headAngle -= 360 sinMultR = math.sin(math.radians(headAngle)) cosMultR = math.cos(math.radians(headAngle)) graphics.DrawLine(self.offscreen_canvas, centerX + (sinMultR * (handLength - 1)), centerY - (cosMultR * (handLength - 1)), centerX + (sinMult * handLength), centerY - (cosMult * handLength), handColour) dispString = "%2.0f" % (float(windSpeed)) if float(windSpeed) < 10: charWidth = 2 else: charWidth = 0 graphics.DrawText(self.offscreen_canvas, self.__font, (centerX - 3) - charWidth, centerY + 3, handColour, dispString)
def show_weather(self): time.sleep(0.01) self.canvas = self.matrix.SwapOnVSync(self.canvas) self.canvas.Clear() # Request every 10 mins if self.last_weather_request + 600 < time.time(): url = "https://api.darksky.net/forecast/{}/36.65794,-4.5422482?units=si&exclude=hourly,daily".format(config.weather_key) response = requests.get(url).json() self.temperature = str(int(response['currently']['temperature'])) self.humidity = str(response['currently']['humidity'] * 100).split('.')[0] icon = response['currently']['icon'] try: self.image = Image.open("./weather_icons/{}8.png".format(icon)) except: print("ERROR Weather icon does not exist: {}".format(icon)) self.image = Image.open("./weather_icons/unknown8.png") self.last_weather_request = time.time() self.image.thumbnail((self.matrix.width, self.matrix.height), Image.ANTIALIAS) self.matrix.SetImage(self.image.convert('RGB'), 0 ,7 ) #graphics.DrawText(self.matrix, self.font, 20, 6, self.yellow, self.temperature) #graphics.DrawCircle(self.matrix, 29, 2, 1, self.yellow) #graphics.DrawText(self.matrix, self.font, 20, 14, self.blue, "{}%".format(self.humidity)) graphics.DrawText(self.matrix, self.font, 9, 13, self.yellow, "{}".format(self.temperature)) graphics.DrawCircle(self.matrix, 18, 9, 1, self.yellow) graphics.DrawText(self.matrix, self.font, 21, 13, self.blue, "{}%".format(self.humidity)) str_time = "{}:{}".format( str(self.hour).zfill(2), str(self.minute).zfill(2)) graphics.DrawText(self.matrix, self.font, 7, 5, self.blue, str_time) time.sleep(5)
print " my = ", mag['y'], ": ", lowestMY, " - ", highestMY #print " mz = " , ( mag['z'] ) print('') skip = 0 while not done: if skip > 2: skip = 0 mag = mpu9250.readMagnet() x = ((mag['x'] + 45) / 100) * -1 y = ((mag['y'] - 20) / 100) * -1 verlet.gravity = Vector2D(x, y) # print x, y else: skip += 1 verlet.runTimeStep() matrix.Clear() for particle in verlet.particles: graphics.DrawCircle(matrix, int(particle.vector.x), int(particle.vector.y), particle.radius, particle.data['color']) # graphics.DrawLine(matrix, 5, 5, 22, 13, red) # time.sleep(10) # show display for 10 seconds before exit
def check_radius(): while True: for circle in list_circles: if (circle.radius == 9): list_circles.remove(circle) try: print('Press CTRL-C to stop.') canvas = matrix.CreateFrameCanvas() thread1 = Thread(target=add_circle) thread2 = Thread(target=check_radius) thread1.daemon = True thread2.daemon = True thread1.start() thread2.start() while True: canvas.Clear() for circle in list_circles: index = random.randint(0, 6) current_color = circle.color graphics.DrawCircle(canvas, circle.x, circle.y, circle.radius, current_color) circle.radius = circle.radius + 1 canvas = matrix.SwapOnVSync(canvas) time.sleep(0.125) except KeyboardInterrupt: sys.exit(0)
def draw_circle(self, x: int, y: int, radius: int, color: int): color = graphics.Color(*hex2rgb(color)) graphics.DrawCircle(self.canvas, x, y, radius, color)
def run(self): self.logger.info("Starting display thread") options = RGBMatrixOptions() options.rows = 32 options.cols = 64 options.chain_length = 1 options.parallel = 1 options.hardware_mapping = 'regular' # If you have an Adafruit HAT: 'adafruit-hat' matrix = RGBMatrix(options=options) offscreen_canvas = matrix.CreateFrameCanvas() font = graphics.Font() font.LoadFont("rpi-rgb-led-matrix/fonts/tom-thumb.bdf") font2 = graphics.Font() font2.LoadFont("rpi-rgb-led-matrix/fonts/6x12.bdf") font3 = graphics.Font() font3.LoadFont("rpi-rgb-led-matrix/fonts/4x6.bdf") font4 = graphics.Font() font4.LoadFont("rpi-rgb-led-matrix/fonts/6x9.bdf") home_image = Image.open("blue_house1.bmp").convert('RGB') black = graphics.Color(0, 0, 0) red = graphics.Color(128, 0, 0) purple = graphics.Color(28, 65, 84) lightBlue = graphics.Color(0, 0, 128) dark_blue = graphics.Color(0, 0, 32) green = graphics.Color(0, 128, 0) orange = graphics.Color(128, 75, 0) while True: try: offscreen_canvas.Clear() offscreen_canvas.brightness = \ self.collection.brightness * min(self.collection.ambient_light * 2 + 10, 100) if self.collection.screen == SCREEN_TRAINS: graphics.DrawLine(offscreen_canvas, 0, 1, 63, 1, dark_blue) for index, dep in enumerate(self.collection.departure_list, start=0): if dep.delay < 1: dep_color = green elif dep.delay < 8: dep_color = orange else: dep_color = red y0 = index * 6 + 2 y1 = y0 + 5 text_length = graphics.DrawText(offscreen_canvas, font, dep.display.pos, y1, dep_color, dep.text1()) dep.display.scroll(text_length) for y in range(y0, y1): graphics.DrawLine(offscreen_canvas, 45, y, 63, y, black) graphics.DrawLine(offscreen_canvas, 45 - 1, y0, 45 - 1, y1, dark_blue) graphics.DrawLine(offscreen_canvas, 0, y1, 63, y1, dark_blue) graphics.DrawText(offscreen_canvas, font, 45, y1, dep_color, dep.text2()) offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas) time.sleep(0.03) elif self.collection.screen == SCREEN_INDOOR: graphics.DrawLine(offscreen_canvas, 0, 5, 63, 5, dark_blue) graphics.DrawText(offscreen_canvas, font, 2, 5, red, f'{self.collection.datetime}') indoor = self.collection.indoor_environment_data temp_text_length = graphics.DrawText(offscreen_canvas, font2, 0, 14, green, f'{indoor.temperature:.2f} C') graphics.DrawText(offscreen_canvas, font2, 0, 23, green, f'{indoor.humidity:.2f} %') graphics.DrawCircle(offscreen_canvas, temp_text_length - 8, 8, 1, green) graphics.DrawText(offscreen_canvas, font2, 0, 32, green, f'{indoor.pressure:.1f} hPa') offscreen_canvas.SetImage(home_image, 45, 7) offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas) time.sleep(0.1) elif self.collection.screen == SCREEN_OUTDOOR: outdoor = self.collection.current_weather_data graphics.DrawLine(offscreen_canvas, 0, 5, 63, 5, dark_blue) header_text_length = graphics.DrawText(offscreen_canvas, font, outdoor.header_text.pos, 5, red, outdoor.header_text.text) outdoor.header_text.scroll(header_text_length) temp_text_length = graphics.DrawText(offscreen_canvas, font2, 0, 14, green, f'{outdoor.temperature} C') graphics.DrawCircle(offscreen_canvas, temp_text_length - 8, 8, 1, green) graphics.DrawText(offscreen_canvas, font2, 0, 23, green, f'{outdoor.humidity} %') offscreen_canvas.SetImage(outdoor.weather_icon, 45, 7) # detail1_length = graphics.DrawText(offscreen_canvas, font, outdoor.detail_text1.pos, 25, green, outdoor.detail_text1.text) # outdoor.detail_text1.scroll(detail1_length) detail2_length = graphics.DrawText(offscreen_canvas, font2, outdoor.detail_text2.pos, 31, green, outdoor.detail_text2.text) outdoor.detail_text2.scroll(detail2_length) offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas) time.sleep(0.03) # elif (self.collection.screen in [SCREEN_FORECAST_1, SCREEN_FORECAST_2, SCREEN_FORECAST_3]): elif ( self.collection.screen == SCREEN_FORECAST_1 or self.collection.screen == SCREEN_FORECAST_2 or self.collection.screen == SCREEN_FORECAST_3): offset = 0 if self.collection.screen == SCREEN_FORECAST_2: offset = 4 elif self.collection.screen == SCREEN_FORECAST_3: offset = 8 graphics.DrawLine(offscreen_canvas, 0, 5, 63, 5, dark_blue) graphics.DrawText(offscreen_canvas, font, 0, 5, purple, f'{self.collection.current_weather_data.city} {self.collection.forecast_list[offset].weekday}') graphics.DrawText(offscreen_canvas, font, 0, 11, green, f'{self.collection.forecast_list[offset].timestr} {self.collection.forecast_list[offset].temp}C') # graphics.DrawText(offscreen_canvas, font, 0, 17, green, f'{self.collection.forecast_list[offset].weather_desc}') detail_length1 = graphics.DrawText(offscreen_canvas, font, self.collection.forecast_list[offset].detail_text.pos, 17, green, f'{self.collection.forecast_list[offset].detail_text.text}') self.collection.forecast_list[offset].detail_text.scroll(detail_length1) graphics.DrawLine(offscreen_canvas, 0, 18, 63, 18, dark_blue) graphics.DrawText(offscreen_canvas, font, 0, 25, green, f'{self.collection.forecast_list[offset + 2].timestr} {self.collection.forecast_list[offset + 2].temp}C') # graphics.DrawText(offscreen_canvas, font, 0, 31, green, f'{self.collection.forecast_list[offset+2].weather_desc}') detail_length2 = graphics.DrawText(offscreen_canvas, font, self.collection.forecast_list[offset + 2].detail_text.pos, 31, green, f'{self.collection.forecast_list[offset + 2].detail_text.text}') self.collection.forecast_list[offset + 2].detail_text.scroll(detail_length2) offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas) time.sleep(0.03) elif self.collection.screen == SCREEN_NEWS: # graphics.DrawLine(offscreen_canvas, 0, 1, 63, 1, dark_blue) for index, dep in enumerate(self.collection.news_list, start=0): # if dep.delay < 1: dep_color = green y0 = index * 6 + 2 y1 = y0 + 5 text_length = graphics.DrawText(offscreen_canvas, font, dep.text.pos, y1, dep_color, dep.text.text) dep.text.scroll(text_length) offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas) time.sleep(0.03) except Exception as e: self.logger.error('Failed to show display: %s', str(e)) time.sleep(3)
def render_pick_ups(canvas): for pick_up in pick_ups: graphics.DrawCircle(canvas, pick_up.x, pick_up.y, pick_up.radius, pick_up.color) canvas = matrix.SwapOnVSync(canvas)
win = True # Function that quits keyboard input and then exits the whole program def quit_program(): curses.endwin() sys.exit(1) # Main loop that starts the timer daemon thread and waits for user keyboard input player_x = 1 player_y = 1 try: create_pick_ups() render_everything(canvas) graphics.DrawCircle(canvas, player_x, player_y, 0, blue_color) canvas = matrix.SwapOnVSync(canvas) timer_thread = Thread(target=timer, args=(canvas, )) timer_thread.daemon = True timer_thread.start() key = '' while timer_thread.is_alive() == True: key = stdscr.getch() stdscr.addch(20, 25, key) stdscr.refresh() check_boundry = 0 canvas.Clear() if key == ord('w'): check_boundry = player_y check_boundry -= 1 if (check_boundry >= 0):
def main(win): # 32 Rows, 2 panel, 1 chain MyMatrix = RGBMatrix(32, 2, 1) # Bits used for PWM. Something between 1..11. Default: 11 MyMatrix.pwmBits = 11 # Sets brightness level. Default: 100. Range: 1..100" MyMatrix.brightness = 100 # Buffer canvas. MyOffsetCanvas = MyMatrix.CreateFrameCanvas() # setup colours for border, paddles and ball red = graphics.Color(255, 0, 0) green = graphics.Color(0, 255, 0) blue = graphics.Color(0, 0, 255) white = graphics.Color(255, 255, 255) black = graphics.Color(0, 0, 0) grey = graphics.Color(128, 128, 128) # set player1 paddle start p1x = 2 p1y = 12 # set player2 paddle start p2x = 61 p2y = 12 # set the ball start ballx = 32 bally = 16 # Set the ball movement xballmovement = +1 yballmovement = -1 # start the main loop going = True win.nodelay(True) # make getkey() not wait while going: try: key = win.getkey() except: # in no delay mode getkey raise and exeption if no key is press key = None #endtry if key == "x": going = False break #endif # player1 paddle down if key == "q": p1y = p1y - 1 #endif # player1 paddle down if key == "a": p1y = p1y + 1 #endif # player2 paddle up if key == "p": p2y = p2y - 1 #endif # player2 paddle down if key == "l": p2y = p2y + 1 #endif ballx = ballx + xballmovement bally = bally + yballmovement p1y = bally - 4 p2y = bally - 4 MyMatrix.Clear() # draw the border graphics.DrawLine(MyOffsetCanvas, 0, 0, 63, 0, white) graphics.DrawLine(MyOffsetCanvas, 0, 0, 0, 31, white) graphics.DrawLine(MyOffsetCanvas, 63, 0, 63, 31, white) graphics.DrawLine(MyOffsetCanvas, 0, 31, 63, 31, white) # draw player1 paddle graphics.DrawLine(MyOffsetCanvas, p1x, p1y, p1x, p1y + 8, red) # draw player2 paddle graphics.DrawLine(MyOffsetCanvas, p2x, p2y, p2x, p2y + 8, green) # draw the ball graphics.DrawCircle(MyOffsetCanvas, ballx, bally, 1, blue) # Collision Detect collision_type = fnDetectCollision(p1x, p1y, p2x, p2y, ballx, bally) if collision_type == PADDLE1: xballmovement = +1 #endif if collision_type == PADDLE2: xballmovement = -1 #endif if collision_type == TOP: yballmovement = +1 #endif if collision_type == BOTTOM: yballmovement = -1 #endif if collision_type == LEFT_EDGE: xballmovement = +1 #endif if collision_type == RIGHT_EDGE: xballmovement = -1 #endif # flip on vsync MyOffsetCanvas = MyMatrix.SwapOnVSync(MyOffsetCanvas) # Wait a bit time.sleep(0.005) #endwhile return
def pong_loop(self): ## Stick logic if self.ball_x < self.canvas.width/2: if self.left_needs_to_lose: pass elif self.ball_y < self.stick_left: self.stick_left -= 1 else: self.stick_left += 1 else: if self.right_needs_to_lose: pass elif self.ball_y < self.stick_right: self.stick_right -= 1 else: self.stick_right += 1 ## Ball logic if self.ball_y < 1 or self.ball_y > self.canvas.height-1: self.is_up = not self.is_up if self.ball_x < 2: if self.left_needs_to_lose: self.minute = datetime.now().minute self.ball_x = self.canvas.width/2 self.ball_y = self.canvas.height/2 self.left_needs_to_lose = False else: self.is_left = not self.is_left if self.ball_x > self.canvas.width-3: if self.right_needs_to_lose: self.hour = datetime.now().hour self.ball_x = self.canvas.width/2 self.ball_y = self.canvas.height/2 self.right_needs_to_lose = False else: self.is_left = not self.is_left if self.is_left: self.ball_x = self.ball_x - 1 else: self.ball_x = self.ball_x + 1 if self.is_up: self.ball_y = self.ball_y -1 else: self.ball_y = self.ball_y +1 # Drawing #graphics.DrawLine(canvas, 5, 5, 22, 13, red) graphics.DrawLine(self.canvas, self.canvas.width/2, 0, self.canvas.width/2, self.canvas.height, self.white) graphics.DrawLine(self.canvas, 0, self.stick_left -2 , 0, self.stick_left +2, self.green) graphics.DrawLine(self.canvas, self.canvas.width-1, self.stick_right - 2, self.canvas.width-1, self.stick_right + 2, self.red) graphics.DrawCircle(self.canvas, self.ball_x, self.ball_y, 0, self.white) str_time = "{} {}".format( str(self.hour).zfill(2), str(self.minute).zfill(2)) graphics.DrawText(self.canvas, self.font, 7, 5, self.blue, str_time) # Change time if self.minute != datetime.now().minute: self.left_needs_to_lose = True if self.hour != datetime.now().hour: self.right_needs_to_lose = True time.sleep(0.1) # show display for 10 seconds before exit
def draw(self, canvas): graphics.DrawCircle(canvas, self.x, self.y, self.radius, white)