def __init__(self):
self.screen = screen.Screen(560, 384)
#pygame.display.set_caption("ApplePy")
self.mix = False
self.flash_time = time.time()
self.flash_on = False
self.flash_chars = [[0] * 0x400] * 2
self.page = 1
self.text = True
self.colour = False
self.chargen = []
for c in self.characters:
chars = [[numpy.zeros((14, 16, 3)),
numpy.zeros((14, 16, 3))],
[numpy.zeros((14, 16, 3)),
numpy.zeros((14, 16, 3))]]
for colour in (0, 1):
hue = (255, 255, 255) if colour else (0, 200, 0)
for inv in (0, 1):
#pixels = chars[colour][inv]
off = hue if inv else (0, 0, 0)
on = (0, 0, 0) if inv else hue
for row in range(8):
b = c[row] << 1
for col in range(7):
bit = (b >> (6 - col)) & 1
chars[colour][inv][2 *
col][2 *
row] = on if bit else off
chars[colour][inv][2 * col +
1][2 * row] = on if bit else off
#del pixels
self.chargen.append(chars)
def test_screen():
try:
b = board.Board(1)
scr = screen.Screen(b)
scr.draw_board()
time.sleep(.1)
scr.set_scheme('inverted')
scr.draw_board()
time.sleep(.1)
scr.set_scheme('mono')
scr.draw_board()
time.sleep(.1)
scr.set_scheme('mono-inverted')
scr.draw_board()
time.sleep(.1)
scr.set_scheme('normal')
scr.draw_board()
scr.teardown()
return True
except Exception as e:
print(e)
exceptions.append(e)
traceback.print_exc()
return False
def run(self, stdscr):
"""
This method is called by the curses.wrapper to start the mainloop and
screen.
:param stdscr: curses screen passed in from curses.wrapper
"""
# We want to do an interactive session, so start up the curses screen and
# pass it the function that handles commands
colors.init_colors()
self.screen = screen.Screen(stdscr, self.do_command, self.tab_completer, self.encoding)
self.statusbars = StatusBars()
self.eventlog = EventLog()
self.screen.topbar = "{!status!}Deluge " + deluge.common.get_version() + " Console"
self.screen.bottombar = "{!status!}"
self.screen.refresh()
# The Screen object is designed to run as a twisted reader so that it
# can use twisted's select poll for non-blocking user input.
reactor.addReader(self.screen)
# Start the twisted mainloop
reactor.run()
def run():
"""Run the program."""
uart = UART(1)
uart.init(config.baudrate,
bits=8,
parity=None,
stop=1,
rx=config.rx,
tx=config.tx)
gps = MicropyGPS()
s = screen.Screen()
kph = None
start = utime.ticks_ms()
while kph is None and utime.ticks_diff(utime.ticks_ms(), start) < 1000:
if uart.any():
try:
stat = gps.update(chr(uart.read(1)[0]))
except:
pass
if stat == 'GNRMC':
print(stat)
kph = gps.speed[2]
if kph is not None:
s.update(kph)
machine.deepsleep(5000)
def __init__(self):
cu = 5
width = 600
self.__root = tkinter.Tk()
self.__screen = screen.Screen(self.__root,
height=width,
width=width,
columns=cu,
raws=cu)
tkinter.Button(self.__root,
text="Quit",
command=self.__quit,
bg='#d8d3cb').pack(fill=tkinter.X)
self.__game = game.Game(columns=cu, raws=cu)
self.__play = True
self.__interval = 0.5
self.__input_pipe = {
0: AIInputPipe(
self.__game,
0,
1,
),
1: ClickerInputPipe(1, self.__screen.getCanvas(), self)
}
self.__id_hash = {}
self.__running = True
self.__root.update_idletasks()
self.__root.update()
def __init__(el):
el.prompt = 'ExpList> '
el.s = screen.Screen(h=15, w=40)
el.expt = exptree.ExpTree(el.s,
cmds=[('a', 'add'), ('d', 'delete'),
('p', 'modprice'), ('l', 'list'),
('c', 'conv-rate'), ('N', 'ch name'),
('s', 'ch src'), ('S', 'save'),
('sh', 'mod win ht'),
('sw', 'mod win wd'),
('sp', 'mod def pay'),
('sa', 'add pay abr'),
('ss', 'mod start page'),
('sc', 'mod conv rate'),
('sdl', 'vw/del ab'),
('A', 'accounts'),
('D', 'delete subtree')])
el.el_file = 'save_expt.txt'
el.expt.safe_loader(el.el_file)
el.sts = settings.Settings(el.expt, el.s)
el.sts.read_exptree()
el.s.h = el.sts.set_dict['win_height']
el.s.w = el.sts.set_dict['win_width']
el.s.setscreen()
el.s.display()
el.def_src = el.sts.set_dict['def_pay_src']
el.start_pos = el.sts.set_dict['start_pos']
def __init__(self):
self.screen = screen.Screen(180)
self.last_ready = time.time()
self.last_temp = 0
self.thermocouple = MAX31856(software_spi=SOFTWARE_SPI)
self.status_url = os.environ["COFFEE_STATUS_URL"]
atexit.register(self.screen.clear)
def __init__(self):
pygame.init()
self.screen = screen.Screen(ScreenWidth, ScreenHeight)
self.screen.background = dark_gray
self.game = game.Game()
self.keyEventHandeler = []
def main():
""" Main function for photocopier, this is where it starts. """
# Toggle: 1 -> Register
# Toggle: 0 -> Login
scr = screen.Screen()
menu1 = menu.menu_screen(
scr, "Start", ["", "Welcome to the Boring Company photocopier", ""])
# Login
menu1.add_menu("Login", account.register_or_login, False, screen=scr,
toggle=True)
# Register
menu1.add_menu("Register", account.register_or_login, False, screen=scr,
toggle=False)
# Shutdown
menu1.add_menu("Shutdown", shutdown, False, screen=scr)
menu1.print_menu()
ret, info = menu1.select_menu()
if not ret:
account.fix_file()
Home.home(info[0], info[1], info[2], info[3])
else:
return
def test_board():
b = board.Board(1)
scr = screen.Screen(b)
b.set_screen(scr)
try:
for i in range(20):
b.draw()
b.move(RIGHT)
time.sleep(.2)
for i in range(20):
b.draw()
b.move(DOWN)
time.sleep(.2)
for i in range(20):
b.draw()
b.move(RIGHT)
time.sleep(.2)
scr.teardown()
except Exception as e:
scr.teardown()
print(e)
exceptions.append(e)
traceback.print_exc()
def __init__(self):
self.screen = screen.Screen()
self.constant_left = 0
self.blinking_left = 0
self.random_blinking_left = 0
self.tick_counter = 1
self.pause_tick_counter = 0
self.generate_new_screen()
def main():
pygame.init()
canvas = screen.Screen()
loop = event_loop.EventLoop(canvas)
loop.start()
def __init__(self, filename: str):
self.comp = comp.Computer(output_to_screen=False) # The game needs a computer to run game logic.
self.comp.load_file(filename) # Load program from parm filename into computer memory.
self.scr = screen.Screen() # The game needs a screen.
self.ball = (0, 0) # Current (x, y) position of the ball.
self.paddle = (0, 0) # Current (x, y) position of the paddle.
self.score = 0 # Player's score.
self.frames = 0 # Number of frames so far.
def audio(self):
con = connect("storer.db")
cur = con.cursor()
cur.execute("select * from Storer")
cur.execute(" update Storer set count ='{0}' ".format(0))
con.commit()
self.destroy()
screen.Screen()
def __init__(self):
print 'Initializing game.'
#using pygame
pygame.init()
self.clock = pygame.time.Clock()
self.paddle = o.Paddle()
self.ball = o.Ball()
self.block_container = o.BlockContainer()
self.screen = s.Screen(pygame)
self.input = i.Input(pygame)
def __init__(self):
self.between = False
self.win_message = ''
self.screen = screen.Screen()
self.state = 1
self.stack = []
deck = [card.CARDS[int(i)].copy() for i in [random.random() * len(card.CARDS) for _ in range(40)]]
self.player1 = player.Player(1, deck)
self.player2 = player.Player(2, deck)
self.current_player = 1
def __init__(self):
self.screen = scr = screen.Screen()
self.memory = _build_memory(self.screen)
self.cpu = _build_cpu(self.memory)
self.gatearray = cpcio.GateArray(self.cpu, self.memory, scr)
self.ppi8255 = cpcio.PPI8255(self.cpu)
self.printer = cpcio.PrinterPort(self.cpu)
self.crtc = cpcio.Crtc(self.cpu, scr)
self.rombank = cpcio.RomBank(self.cpu, self.memory)
self.floppy = cpcio.Floppy(self.cpu)
def __init__(self):
self.dummy = use_dummy
if use_dummy:
self.pos = (0, 0)
self.rows = [ " " * 16, " " * 16 ]
sys.stdout.write(chr(0x1b) + "[2J")
sys.stdout.flush()
else:
self.bus = SMBus(1)
self.backlight = backlight.Backlight(self.bus, 0x62)
self.screen = screen.Screen(self.bus, 0x3e)
def main():
with open('input') as f:
input = f.read()
parser = screen.ScriptParser(input)
s = screen.Screen(50, 6)
for instruction in parser.instructions():
instruction.execute(s)
s.draw()
print(s.count_enabled())
def __init__(self):
pygame.init()
import screen
self.screen = screen.Screen(ScreenWidth, ScreenHeight)
self.screen.background = dark_gray
from menu_main import MainMenu
self.mainMenu = MainMenu(self)
#self.game = game.Game()
self.keyEventHandeler = []
def run():
"""Main entry point to execute this program."""
try:
bme = bme280.BME280(i2c=_i2c, mode=bme280.BME280_OSAMPLE_4)
scr = screen.Screen(config)
if _delete_ccs811_baseline_requested():
_baseline.delete()
if _is_first_run():
# 20 runs (minutes), p9 of datasheet
_set_runs_to_condition(20)
ccs = ccs811.CCS811(_i2c, mode=ccs811.CCS811.DRIVE_MODE_60SEC)
t, p, h = bme.read_data()
# Full update of Waveshare on power on
scr.update(t, h, None, None, _bat.volts(), False, True)
else:
ccs = ccs811.CCS811(_i2c, mode=None)
_add_run()
ccs.read()
t, p, h = bme.read_data()
ccs.put_envdata(t, h)
if _ccs811_is_conditioned():
# Stored baseline should only be loaded after conditioning
if not _ccs811_baseline_is_loaded() and _baseline.exists():
baseline = _baseline.retrieve()
ccs.put_baseline(baseline)
_set_ccs811_baseline_loaded()
scr.update(t, h, None, None, _bat.volts())
print('ccs811 baseline %d loaded' % baseline)
else:
scr.update(t, h, ccs.eco2, ccs.tvoc, _bat.volts(),
_ccs811_baseline_is_loaded())
if _new_ccs811_baseline_requested():
baseline = ccs.get_baseline()
_baseline.store(baseline)
print('ccs811 baseline %d stored' % baseline)
else:
scr.update(t, h, None, None, _bat.volts())
print('eCO2: %dppm, TVOC: %dppb, %.1fC, %.1f%%RH, baseline: %r' %
(ccs.eco2, ccs.tvoc, t, h, _ccs811_baseline_is_loaded()))
scr.sleep()
_flash_led()
except Exception as e:
_flash_led(3)
print(e)
esp32.wake_on_ext0(pin=config.int, level=0)
machine.deepsleep()
def photo(self):
con = connect("storer.db")
cur = con.cursor()
cur.execute("select * from Storer")
cur.execute(" update Storer set count ='{0}' ".format(3))
con.commit()
self.destroy()
screen.Screen()
#x=Home()
#x.mainloop()
def main(verbose=False):
t_sensor = None
screen = None
thermostat = None
scheduler = None
try:
t_sensor = D.TempSensor()
except Exception as ex:
print("Cannot reach the sensor, check wiring. Aborting..")
print(ex)
try:
scheduler = Scheduler.SchedManager()
except Exception as ex:
print("A problem occurs while initialising Scheduler obj.")
print(ex)
# Create and init Screen
if t_sensor is not None and scheduler is not None:
try:
thermostat = T.Thermostat(t_sensor, scheduler, verbose)
screen = S.Screen(t_sensor, scheduler, verbose)
except Exception as ex:
print(ex)
try:
if thermostat is not None:
thermostat.start()
if screen is not None:
#screen.setParam(t_sensor.get_temp(), 20, 1)
screen.start()
while True:
time.sleep(1)
except (Exception, KeyboardInterrupt) as ex:
print("Exiting, raised exception.")
print(ex)
screen.stop()
thermostat.stop()
screen.join()
thermostat.join()
print("Everything ok.")
if screen.is_alive():
screen.stop()
screen.join()
if thermostat.is_alive():
thermostat.stop()
thermostat.join()
def game_loop():
# create chip8 object
c8 = chip8.Chip8()
#create a tkinter window
root = tkinter.Tk()
#Create a window that will ask the user to select the rom they
#would like to use
file_name = filedialog.askopenfilename(
initialdir = os.getcwd(),
filetypes = (("Chip-8 ROMs *.ch8","*.ch8"), ("Chip-8 ROMS *.c8","*.c8")),
title = 'Select Game')
#Error message if no rom is detected
if file_name == '':
messagebox.showinfo('', 'Error: No ROM selected')
root.destroy()
return
root.destroy()
#Create new screen object
scr = screen.Screen(scale, c8)
#initiate that object's display
scr.initiate_display()
c8.load_rom(file_name)
running = True
while running:
#sends opcode from rom to be decoded and run
c8.emulate_cycle(scr)
#if last opcode was Dxyn call draw_sprite and update screen
if c8.draw_flag == True:
scr.draw_sprite(chip8)
scr.update_screen()
c8.draw_flag = False
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
key_pressed = pygame.key.get_pressed()
if key_pressed[pygame.K_ESCAPE]:
running = False
scr.destroy()
def __init__(self):
self.prevKey = ''
self.should_keep_going = True
self.paused = False
self.hp = 30
self.wordDictionary = dictionary.Dictionary("dictionary_testfile")
self.stat = stats.Stats()
self.scrn = screen.Screen(self.stat)
self.scrn.scr.nodelay(1)
self.words = []
self.wordsOnScreen = 10
self.pos_in_word = 0
self.last_time = datetime.datetime.now()
self.probableWords = []
self.poss_vals = list(range(1, self.scrn.height - 10))
debug.init()
self.new_game()
def main():
machine.freq(160000000)
count = _SCREEN_REFRESH
# try:
conf_class = config.Config()
conf_data = conf_class.load_config()
# counter_class = counter.Counter(9, 10, conf_data)
screen_class = screen.Screen(conf_data)
temperature_class = temperature.Temperature(4, 5, conf_data, screen_class)
screen_class.write_display()
screen_class.write_data()
while True:
temperature_class.temperature()
conf_data['p']['l'] = temperature_class.temp_level()
time.sleep_ms(1000)
count -= 1
if count <= 0:
screen_class.write_data()
count = _SCREEN_REFRESH
class Manager():
wordDictionary = Dictionary.Dictionary(test)
scrn = screen.Screen()
stat = stats.Stats()
words = []
wordsOnScreen = 10
def new_game(self):
'''
starts a new game
'''
for i in range(wordsOnScreen):
w = wordDictionary.pick_word()
x = random.randint(scrn.width)
y = 0
self.words = word.Word(w, x, y)
def __init__(self):
self.wordDictionary.import_dictionary()
self.hp = 10
self.new_game()
def restart(self):
new_game()
def process_input(self):
pass
def game_loop(self):
while self.hp > 0:
#render words
self.scrn.clear()
for word in self.words:
self.scrn.render_word(word)
self.scrn.render_stats(self.stat)
self.process_input()
#update data
return self.stat
def loadScreen(width=600, cu=10):
logging.info(' > function -> loadScreen ')
__root = tkinter.Tk()
__screen = screen.Screen(__root,
height=width,
width=width,
columns=cu,
raws=cu)
_id = __screen.drawTool(1, 1, player=0)
print(_id)
__screen.drawTool(3, 5, player=0)
__screen.drawTool(3, 6, player=1)
__screen.drawTool(6, 5, player=1)
logging.info(' > exit function ( loadScreen )')
__screen.animate(_id, 1, 5)
def loop():
threading.Timer(loop, 5).start()
loop()
threading.Timer(__root.mainloop(), 5).start()
def __init__(self):
self.running = False
game.init()
self.screen = screen.Screen()
game.game = self
game.screen = self.screen
self.clock = pygame.time.Clock()
self.scene_num = 0
self.scenes = []
fx.init()
self.ldraw = None
self.activescenestack = []
self.teen = contactnode.make_teen()
game.teen = self.teen
self.script = game.script = scriptmanager.ScriptManager(
"../res/script.txt", "../res/contacts.txt")
#game.active_node = emailnode.test_email()
#game.active_node = commentgame.CommentGame()
#game.active_node = title.Title()
sound.play_music()
#/usr/bin/python2.7
import dot3k.joystick as j
import time
import sys
import os
import signal
import screen, backlight, ledbar, temperature, joystick
MESSAGE = screen.Screen()
TEMP = temperature.Temperature()
LED = ledbar.LedBar()
SCROLLER = joystick.Scroller()
LIGHT = backlight.Backlight()
def main():
if SCROLLER.scrollnum >= len(TEMP.temperatures):
SCROLLER.reset()
if SCROLLER.scrollnum < 0:
SCROLLER.scrollnum = len(TEMP.temperatures) - 1
MESSAGE.writeTemp(TEMP.temperatures[SCROLLER.scrollnum])
LIGHT.color(float(TEMP.temperatures[SCROLLER.scrollnum]))
LED.set_size(float(TEMP.temperatures[SCROLLER.scrollnum]))
return
@j.on(j.UP)
def handle_up(pin):
MESSAGE.clearScreen()
TEMP.readTemp()
