def splashscreen():
#show splashscreen
splashwindow = Window(app, "Erelas monitoring system", width=450, height = 100)
splashtext = Text(splashwindow, text="Device status monitored by Erelas monitoring system")
splashtext2 = Text(splashwindow, text = "https://github.com/moth754/Erelas-Local-Monitor")
splashwindow.show()
sleep(3)
splashwindow.hide()
def question3():
global sb, txt, qth
qth = Window(app, title="Question Three", width=800, height=400)
qth.show()
print("start question 3")
txt = Text(qth, text="Hold the screen out in front of you")
txt.text_size = 40
txt.text_color = 'magenta'
sb = PushButton(qth, text="Begin", padx=240, pady=80, command=balancetest)
sb.bg = 'green'
sb.text_size = 100
class NewTask():
'''NewTask GUI'''
def __init__(self, app, callback):
'''Class contructor'''
self.callback = callback
self.window_new = Window(app, title="Add Task")
Text(self.window_new, "Add new task title")
self.title = TextBox(self.window_new,
command=self.check_empty,
width="fill")
Text(self.window_new, "Add new task description")
self.desc_box = Box(self.window_new,
align="top",
width="fill",
height="fill",
border=True)
self.btn_box = Box(self.window_new,
align="bottom",
width="fill",
border=True)
self.description = TextBox(self.desc_box,
command=self.check_empty,
width="fill",
height="fill",
multiline=True,
scrollbar=True)
PushButton(self.btn_box,
command=self.window_new.destroy,
align="left",
width="fill",
text="Cancel")
self.add_btn = PushButton(self.btn_box,
enabled=False,
align="left",
width="fill",
command=self.add_task,
text="Add")
self.window_new.tk.resizable(True, False)
self.window_new.show()
def check_empty(self):
'''disable add button if title and description are empty'''
if self.title.value != "" and self.description.value != "\n":
self.add_btn.enable()
else:
self.add_btn.disable()
def add_task(self):
'''callback with new title and description'''
self.callback(self.title.value, self.description.value)
self.window_new.destroy()
def copy():
copy_window = Window(json_editor_window, title="create a copy")
copy_window.show(wait=True)
Text(copy_window, text="Name of copy :")
file_name = TextBox(copy_window,
text=file_display.value,
enabled=True,
width="fill")
file_name.when_left_button_released = text_click
def complete_copy():
destination = file_name.value
save(0, destination)
copy_window.destroy()
ok_button = PushButton(copy_window, text="OK", command=complete_copy)
cancel_button = PushButton(copy_window,
text="cancel",
command=copy_window.destroy)
def findTweets():
user = textBox.value
app.hide()
# Loading Window Appears
loadingWindow = Window(app, title="Loading Tweets", visible=True)
loadingText = Text(loadingWindow, text="Loading Tweets... This may take up to 30 seconds")
loadingWindow.update()
# Checking to make sure everything is working on console
print(user)
myuser = api.get_user(screen_name=user)
print(user, " has ", myuser.statuses_count, " total tweets")
# Doing our first search so we can get our maxid to search from on the rest
print("First Search...")
for tweet in tw.Cursor(api.user_timeline, screen_name=user).items(200):
tweets.append(tweet)
for tweet in tweets:
maxtweetid = tweet.id
# Doing the rest of our searches resetting the maxid everytime.
print("Rest of searches...")
for x in range(0, 30):
print(x, end=" ", flush=True)
newtweets = tw.Cursor(api.user_timeline,
screen_name=user,
max_id=maxtweetid,
count=0).items(100)
for tweet in newtweets:
maxtweetid = tweet.id
tweets.append(tweet)
tracker = 0
# Close our loading window
loadingWindow.hide()
tweetsWindow = Window(app, title="Tweets for @" + user)
# Setting up our date stuff to print on window Format of datetime: YYYY-MM-DD
createDate = str(myuser.created_at)
createDate = createDate[:4]
todayMonth = datetime.datetime.now()
todayMonth = todayMonth.strftime("%B")
todayDay = str(datetime.date.today())
todayDay = todayDay[8:10]
todayYear = str(datetime.date.today())
todayYear = todayYear[0:4]
text1 = Text(tweetsWindow, text="Tweet(s) from @" + user + " on " + todayMonth + " " + todayDay + " between " +
createDate + "-" + todayYear)
tweetsWindow.hide()
myDate = str(datetime.date.today())
newDate = myDate[4:]
# Setting our text in our tweet window
for tweet in tweets:
if newDate in tweet.created_at.strftime("%Y-%m-%d %H:%M:%S"):
tracker = tracker + 1
text = Text(tweetsWindow,
text="Tweet " + str(tracker) + ": \"" + tweet.text + "\"\n" + str(tweet.created_at) + "\n")
# print("Tweet: ", tracker)
# print("\"" + tweet.text + "\"")
# print(tweet.created_at)
# Display our tweets and program is concluded
exitprogrambutton = PushButton(tweetsWindow, exitprogram, text="Exit")
tweetsWindow.show()
class Gui(object):
def __init__(self):
self.smidgen_number = 0
self.pinch_number = 0
self.dash_number = 0
self.teaspoon_number = 0
self.dispensing_id = Spices.SALT # Default: id is salt (0)
self.dispensing_id_text = SALT_DISPENSING_TEXT # Default: salt
self.dispensing_amount = 0
self.dispensing_flag = False
self.app = App(title="Pestle Co.")
# All code must be added in th event loop
# START
self.option_window = Window(self.app, title="Choosing a spice")
self.option_window.hide() # hide this window for now
self.dispensing_window = Window(self.option_window, title="Dispensing")
self.dispensing_window.hide() # hide this window for now
self.app.set_full_screen()
self.welcome_message = Text(self.app, text="Pestle Co.", size=40, font="Times New Roman", color="blue")
self.start_button = PushButton(self.app, command=self.open_option_window, text="Push to Start")
# Option page
self.salt_button = PushButton(self.option_window, command=self.open_salt_dispensing_window, text="Salt",
align="top")
self.pepper_button = PushButton(self.option_window, command=self.open_pepper_dispensing_window, text="Pepper",
align="top")
self.done_button = PushButton(self.option_window, command=self.close_option_window, text="Done", align="bottom")
# Dispensing page
self.dispensing_text = Text(self.dispensing_window, text=self.dispensing_id_text)
self.smidgen_button = PushButton(self.dispensing_window, command=self.add_a_smidgen, text="Smidgen")
self.smidgen_number_text = Text(self.dispensing_window, text=str(self.smidgen_number) + " Smidgen(s)")
self.pinch_button = PushButton(self.dispensing_window, command=self.add_a_pinch, text="Pinch")
self.pinch_number_text = Text(self.dispensing_window, text=str(self.pinch_number) + " Pinch(es)")
self.dash_button = PushButton(self.dispensing_window, command=self.add_a_dash, text="Dash")
self.dash_number_text = Text(self.dispensing_window, text=str(self.dash_number) + " Dash(es)")
self.teaspoon_button = PushButton(self.dispensing_window, command=self.add_a_teaspoon, text="Teaspoon")
self.teaspoon_number_text = Text(self.dispensing_window, text=str(self.teaspoon_number) + " Teaspoon(s)")
self.dispense_button = PushButton(self.dispensing_window, command=self.final_dispense, text="Dispense",
align="bottom")
self.reset_button = PushButton(self.dispensing_window, command=self.reset_measurement, text="Reset",
align="bottom")
# STOP
self.app.display()
# Helper functions: windows
def open_option_window(self):
self.option_window.show(wait=True)
self.option_window.set_full_screen()
def close_option_window(self):
self.option_window.exit_full_screen()
self.option_window.hide()
self.app.display()
def open_dispensing_window(self):
self.dispensing_window.show(wait=True)
self.dispensing_window.set_full_screen()
def close_dispensing_window(self):
self.dispensing_window.exit_full_screen()
self.dispensing_window.hide()
self.open_option_window()
def open_salt_dispensing_window(self):
self.dispensing_id_text = SALT_DISPENSING_TEXT
self.dispensing_text.set(self.dispensing_id_text)
self.open_dispensing_window()
def open_pepper_dispensing_window(self):
self.dispensing_id_text = PEPPER_DISPENSING_TEXT
self.dispensing_text.set(self.dispensing_id_text)
self.open_dispensing_window()
# Helper functions: dispensing
def add_a_smidgen(self):
self.smidgen_number += 1
self.smidgen_number_text.set(str(self.smidgen_number) + " Smidgen(s)")
self.dispensing_amount += GRAMS_SALT_PER_TEASPOON/SMIDGENS_PER_TEASPOON if self.dispensing_id == Spices.SALT \
else GRAMS_PEPPER_PER_TEASPOON/SMIDGENS_PER_TEASPOON
def add_a_pinch(self):
self.pinch_number += 1
self.pinch_number_text.set(str(self.pinch_number) + " Pinch(es)")
self.dispensing_amount += GRAMS_SALT_PER_TEASPOON/PINCHES_PER_TEASPOON if self.dispensing_id == Spices.SALT \
else GRAMS_PEPPER_PER_TEASPOON/PINCHES_PER_TEASPOON
def add_a_dash(self):
self.dash_number += 1
self.dash_number_text.set(str(self.dash_number) + " Dash(es)")
self.dispensing_amount += GRAMS_SALT_PER_TEASPOON/DASHES_PER_TEASPOON if self.dispensing_id == Spices.SALT \
else GRAMS_PEPPER_PER_TEASPOON/DASHES_PER_TEASPOON
def add_a_teaspoon(self):
self.teaspoon_number += 1
self.teaspoon_number_text.set(str(self.teaspoon_number) + " Teaspoon(es)")
self.dispensing_amount += GRAMS_SALT_PER_TEASPOON if self.dispensing_id == Spices.SALT \
else GRAMS_PEPPER_PER_TEASPOON
def final_dispense(self):
self.dispensing_flag = True
self.close_dispensing_window() # Return to the dispensing window
self.open_option_window() # Return to the option window
def ready_to_dispense(self):
return self.dispensing_flag
def get_slot_id(self):
return self.dispensing_id
def get_amount_in_grams(self):
return self.dispensing_amount
def reset_measurement(self):
self.smidgen_number = 0
self.smidgen_number_text.set(str(self.smidgen_number) + " Smidgen(s)")
self.pinch_number = 0
self.pinch_number_text.set(str(self.pinch_number) + " Pinch(es)")
self.dash_number = 0
self.dash_number_text.set(str(self.dash_number) + " Dash(es)")
self.teaspoon_number = 0
self.teaspoon_number_text.set(str(self.teaspoon_number) + " Teaspoon(es)")
def generate():
textApp = Window(app, title="Ticket")
nameHeader = Text(textApp, text="Name:")
name = Text(textApp, text=my_name.value)
textApp.show()
text="Made by The Cool Guy 468 and Kidplayer_666",
size=8)
"""Score stuff"""
scoremenu = Window(app)
Scoretext = Text(scoremenu, text="your score is")
Actualscore = Text(scoremenu, text="0")
restbutton2 = PushButton(scoremenu, text="Reset", command=resetthething)
menubutton = PushButton(scoremenu, text="Menu", command=menubuttonthing)
# Waffle setup here for experimental purposes, aka, level size testing
waffle = Waffle(app,
pad=0,
grid=[1, 1],
height=20,
width=20,
color="green",
command=protec,
dim=25)
"""Pixel shuffler"""
pixels = []
for x in range(waffle.width):
for y in range(waffle.height):
pixels.append(waffle.pixel(x, y))
shuffle(pixels)
"""just starting the app"""
app.repeat(750, propagate)
startmenu.show()
scoremenu.hide()
app.hide()
app.display()
class piDSLM:
def __init__(self):
self.capture_number = self.timestamp()
self.video_capture_number = self.timestamp()
self.picture_index = 0
self.saved_pictures = []
self.shown_picture = ""
GPIO.setwarnings(False) # Ignore warning for now
GPIO.setmode(GPIO.BCM) # set up BCM GPIO numbering
GPIO.setup(16, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(16,
GPIO.FALLING,
callback=self.takePicture,
bouncetime=2500)
self.app = App(layout="grid",
title="Camera Controls",
bg="black",
width=480,
height=320)
text0 = Text(self.app, color="white", grid=[1, 0], text="- PiDSLM -")
button1 = PushButton(self.app,
grid=[1, 1],
width=110,
height=110,
pady=35,
padx=10,
image="/home/pi/piDSLM/icon/prev.png",
command=self.long_preview)
text1 = Text(self.app, color="white", grid=[1, 2], text="Focus")
button2 = PushButton(self.app,
grid=[3, 1],
width=110,
height=110,
pady=35,
padx=10,
image="/home/pi/piDSLM/icon/gallery.png",
command=self.show_gallery)
text2 = Text(self.app, color="white", grid=[3, 2], text="Gallery")
button3 = PushButton(self.app,
grid=[5, 1],
width=110,
height=110,
pady=35,
padx=10,
image="/home/pi/piDSLM/icon/vid.png",
command=self.video_capture)
text2 = Text(self.app, color="white", grid=[5, 2], text="HD 30s")
button4 = PushButton(self.app,
grid=[7, 1],
width=110,
height=110,
pady=35,
padx=10,
image="/home/pi/piDSLM/icon/lapse.png",
command=self.burst)
text3 = Text(self.app, color="white", grid=[7, 2], text="Burst")
button5 = PushButton(self.app,
grid=[1, 3],
width=110,
height=110,
image="/home/pi/piDSLM/icon/self.png",
command=self.lapse)
text4 = Text(self.app, color="white", grid=[1, 4], text="1h 60pix")
button6 = PushButton(self.app,
grid=[3, 3],
width=110,
height=110,
image="/home/pi/piDSLM/icon/long.png",
command=self.split_hd_30m)
text2 = Text(self.app, color="white", grid=[3, 4], text="HD 30m in 5s")
button7 = PushButton(self.app,
grid=[5, 3],
width=110,
height=110,
image="/home/pi/piDSLM/icon/drop.png",
command=self.upload)
text3 = Text(self.app, color="white", grid=[5, 4], text="Upload")
button8 = PushButton(self.app,
grid=[7, 3],
width=110,
height=110,
image="/home/pi/piDSLM/icon/del.png",
command=self.clear)
text4 = Text(self.app, color="white", grid=[7, 4], text="Clear Folder")
self.busy = Window(self.app,
bg="red",
height=175,
width=480,
title="busy")
self.app.tk.attributes("-fullscreen", True)
self.busy.hide()
self.app.display()
def clear(self):
self.show_busy()
os.system("rm -v /home/pi/Downloads/*")
self.hide_busy()
def show_busy(self):
self.busy.show()
print("busy now")
def hide_busy(self):
self.busy.hide()
print("no longer busy")
def fullscreen(self):
self.app.tk.attributes("-fullscreen", True)
def notfullscreen(self):
self.app.tk.attributes("-fullscreen", False)
# Generate timestamp string generating name for photos
def timestamp(self):
tstring = datetime.datetime.now()
#print("Filename generated ...")
return tstring.strftime("%Y%m%d_%H%M%S")
def burst(self):
self.show_busy()
capture_number = self.timestamp()
print("Raspistill starts")
os.system(
"raspistill -t 10000 -tl 0 --thumb none -n -bm -o /home/pi/Downloads/BR"
+ str(capture_number) + "%04d.jpg")
print("Raspistill done")
self.hide_busy()
def split_hd_30m(self):
self.show_busy()
capture_number = self.timestamp()
print("Raspivid starts")
os.system("raspivid -f -t 1800000 -sg 300000 -o /home/pi/Downloads/" +
str(capture_number) + "vid%04d.h264")
print("done")
self.hide_busy()
def lapse(self):
self.show_busy()
capture_number = self.timestamp()
print("Raspistill timelapse starts")
os.system(
"raspistill -t 3600000 -tl 60000 --thumb none -n -bm -o /home/pi/Downloads/TL"
+ str(capture_number) + "%04d.jpg")
print("Raspistill timelapse done")
self.hide_busy()
def long_preview(self):
self.show_busy()
print("15 second preview")
os.system("raspistill -f -t 15000")
self.hide_busy()
def capture_image(self):
self.show_busy()
capture_number = self.timestamp()
print("Raspistill starts")
os.system("raspistill -f -o /home/pi/Downloads/" +
str(capture_number) + "cam.jpg")
print("Raspistill done")
self.hide_busy()
def takePicture(self, channel):
print("Button event callback")
capture_number = self.timestamp()
print("Raspistill starts")
os.system("raspistill -f -t 3500 -o /home/pi/Downloads/" +
str(capture_number) + "cam.jpg")
print("Raspistill done")
def picture_left(self):
if (self.picture_index == 0):
self.pictures = (len(self.saved_pictures) - 1)
self.picture_index -= 1
self.shown_picture = self.saved_pictures[self.picture_index]
self.picture_gallery = Picture(self.gallery,
width=360,
height=270,
image=self.shown_picture,
grid=[1, 0])
def picture_right(self):
if (self.picture_index == (len(self.saved_pictures) - 1)):
self.picture_index = 0
self.picture_index += 1
self.shown_picture = self.saved_pictures[self.picture_index]
self.picture_gallery = Picture(self.gallery,
width=360,
height=270,
image=self.shown_picture,
grid=[1, 0])
def show_gallery(self):
self.gallery = Window(self.app,
bg="white",
height=300,
width=460,
layout="grid",
title="Gallery")
self.saved_pictures = glob.glob('/home/pi/Downloads/*.jpg')
self.shown_picture = self.saved_pictures[self.picture_index]
button_left = PushButton(self.gallery,
grid=[0, 0],
width=40,
height=50,
pady=50,
padx=10,
image="/home/pi/piDSLM/icon/left.png",
command=self.picture_left)
self.picture_gallery = Picture(self.gallery,
width=360,
height=270,
image=self.shown_picture,
grid=[1, 0])
button_right = PushButton(self.gallery,
grid=[2, 0],
width=40,
height=50,
pady=50,
padx=10,
image="/home/pi/piDSLM/icon/right.png",
command=self.picture_right)
self.gallery.show()
def video_capture(self):
self.show_busy()
capture_number = self.timestamp()
print("Raspivid starts")
os.system("raspivid -f -t 30000 -o /home/pi/Downloads/" +
str(capture_number) + "vid.h264")
print("done")
self.hide_busy()
def upload(self):
self.show_busy()
subprocess.Popen(
["python3", "/home/pi/piDSLM/dropbox_upload.py", "--yes"])
self.hide_busy()
app = App(title="Coffee Roaster",
width=480,
height=320,
layout="grid",
bg="white")
#Start Screen
startwdw = Window(app,
title="Coffee Roaster",
width=480,
height=320,
layout="grid",
bg="white")
startwdw.tk.attributes("-fullscreen", True)
startwdw.show(wait=True) #welcome window
space = Text(startwdw, text="", grid=[0, 0], size=5)
welcome_message = Text(startwdw,
text=" Coffee Roaster 2.0 ",
grid=[0, 2],
align="left",
size=40,
font="Helvetica",
color="sienna4")
space = Text(startwdw, text="", grid=[0, 3], size=10, align="bottom")
startbt = PushButton(startwdw,
text="START",
command=start_program,
grid=[0, 4],
image="giantbean.gif")
startbt.bg = "black"
class ProgCalc:
def __init__(self, input_excel_db):
self.min_size = 32
self.no_bits = 8
self.value = 0
self.bit_map = {}
self.bit_descr = {}
self.endianess = "big"
self.app = App(layout="grid", height=350, width=550)
self.top_box = Box(self.app, layout = "grid", grid = [0, 0])
self.bottom_box = Box(self.app, layout = "grid", grid = [0, 1])
self.right_box = Box(self.app, grid = [1, 0, 1, 2])
self.window = Window(self.app, width=250, height=150, visible=False)
self.description = Text(self.window)
# Create the text field to enter data
self.input = TextBox(self.top_box, width=25, grid=[0,0,3,1], command=self.process_input)
self.input.bg = "white"
self.input.text_size = 16
# Display the hex value
self.out_hex = Text(self.top_box, grid=[2,1], text="0x<waiting for valid input>")
# Display the min number of bits selector
self.in_minsize = Combo(self.top_box, grid=[0, 1], options=["32"], command=self.process_minsize, selected="32")
# Endianess selector
self.in_endianess = Combo(self.top_box, grid=[1, 1], options=["little", "big"], command=self.process_endianess,
selected=self.endianess)
# Display the binary value
self.out_bin = Text(self.top_box, grid=[0, 2, 2, 1], size=17, text="0b<waiting for valid input>")
# Display little number after the binary value
self.out_num = Text(self.top_box, grid=[0, 3, 2, 1], size=7, text="")
# Prepare the waffle list
self.waffle_list = []
self.box_list = []
self.text_list = []
self.append_wb(4)
self.append_tx(self.no_bits)
# Read the worksheets in the input dictionary and create the list
self.in_excel = openpyxl.load_workbook(filename = input_excel_db, read_only=True)
self.in_regs = self.in_excel.sheetnames
self.in_regs.insert(0, "OFF")
# Display the list of registers
self.in_reglist = ListBox(self.right_box, items = self.in_regs, command=self.process_reglist)
self.input.focus()
self.app.display()
def append_wb(self, number):
last_waffle = len(self.waffle_list)
for i in range(0, 2* number, 2):
w = Waffle(self.bottom_box, height=self.no_bits, width=1, grid=[last_waffle + i, 0])
w.hide()
w.when_clicked = self.process_waffle
self.waffle_list.append(w)
b = Box(self.bottom_box, grid=[i + 1, 0])
b.hide()
self.box_list.append(b)
def append_tx(self, number):
for i in range(0, len(self.box_list)):
try:
tmp = self.text_list[i]
except:
tmp = []
for j in range(0, self.no_bits):
tx = Text(self.box_list[i])
tx.hide()
tx.size = 14 # perfect size for all variants
tx.when_mouse_enters = self.show_description
tx.when_mouse_leaves = self.hide_description
tmp.append(tx)
self.text_list.append(tmp)
def show_description(self, event_data):
name = event_data.widget.value
for elem in self.bit_map:
if self.bit_map[elem] == name:
self.description.value = self.bit_descr[elem]
break
self.window.show()
def hide_description(self, event_data):
self.window.hide()
def process_input(self, inp):
try:
self.value = int(self.input.value, 0)
self.refresh_all()
except ValueError:
return
def process_endianess(self, inp):
self.endianess = inp
self.refresh_all()
def process_minsize(self, opt):
self.min_size = int(opt)
self.refresh_all()
def process_waffle(self, event_data):
# Not sure if this is the best way, but it works
waffleno = int(event_data.y / (event_data.widget.pixel_size + event_data.widget.pad))
waffleno = event_data.widget.height - (waffleno + 1)
# Get WafflePixel based on calculation above - reversed to take into account multiple waffles
idx = 0
for w in reversed(self.waffle_list):
# Skip over invisible waffles
if w.visible == False:
continue
if event_data.widget == w:
break
idx += 1
# See what bit needs to be changed
bit = self.no_bits * idx + waffleno
if self.value & (1 << bit):
self.value &= ~(1 << bit)
else:
self.value |= (1 << bit)
# Refresh display
self.refresh_all()
def process_reglist(self, selected):
if selected == "OFF":
for b in self.box_list:
b.hide()
self.bit_map = {}
self.refresh_all()
return
tmp = self.in_excel[selected]
self.bit_map = {}
for row in tmp.iter_rows():
try:
bits = row[0].value
if bits == None:
break
except IndexError:
break
name = row[1].value
descr = row[2].value
try:
bit = int(bits)
self.bit_map[bit] = name
self.bit_descr[bit] = descr
except ValueError:
if bits == "Bits":
continue
else:
bits = str.replace(bits, "–", "-")
interval = bits.split("-")
for i in range(int(interval[0]), int(interval[1]) + 1):
self.bit_map[i] = name
self.bit_descr[i] = descr
self.refresh_all()
def refresh_all(self):
if "0x" in self.input.value:
self.input.value = hex(self.value)
else:
self.input.value = str(self.value)
# TODO: improve?
self.display_hex()
self.display_bin()
self.display_waffle()
def display_hex(self):
self.out_hex.value = hex(self.value)
def display_bin(self):
# Get binary without 0b
outstring = bin(self.value)[2:]
n = len(outstring)
# Add zeros at beginning if needed
while n % self.min_size != 0:
outstring = "0" + outstring
n += 1
# Split in groups of no_bits
tmp = ""
for idx in range(0, len(outstring)):
tmp += outstring[idx]
if (idx + 1) % self.no_bits == 0:
tmp += " "
outstring = tmp[:-1]
# Handles endianess
if self.endianess == "little":
tmp = ""
for elem in reversed(outstring.split(" ")):
tmp += elem + " "
outstring = tmp
self.out_num.value = "0" + (" " * 140) + "31"
self.out_bin.value = outstring
def display_waffle(self):
# Display new ones, based on the binary representation of the number
idx = 0
x_coord = 0
# Dinamically add waffles if needed
no_waffles = len(self.out_bin.value.split(" "))
if no_waffles > len(self.waffle_list):
self.append_wb(no_waffles - len(self.waffle_list))
for elem in self.out_bin.value.split(" "):
# Somehow it gets a empty element, fix this
if elem == "":
break
# Get the waffle
w = self.waffle_list[x_coord]
w.show() # Display it
if len(self.bit_map) != 0:
b = self.box_list[x_coord]
b.show()
txlist = self.text_list[x_coord]
# Set the individual pixel
for i in range(0, len(elem)):
if len(self.bit_map) != 0:
txlist[i].show()
txlist[i].value = str(idx) + ": " + self.bit_map[idx] + " " * 5
idx += 1
wp = w.pixel(0, i)
if elem[i] == "1":
wp.color = "blue"
else:
wp.color = "white"
x_coord += 1
for i in range(x_coord, len(self.waffle_list)):
self.waffle_list[i].hide()
self.box_list[i].hide()
def questiontwo():
global timelimit
qt = Window(app,
layout="grid",
title="Question Two",
width=800,
height=400)
qt.show()
print("start question 2")
f1 = Box(qt, width=100, height=400, grid=[0, 1])
f1.border = 1
f1.bg = "black"
f2 = Box(qt, width=100, height=400, grid=[1, 1])
f2.border = 1
f2.bg = "black"
f3 = Box(qt, width=100, height=400, grid=[3, 1])
f3.border = 1
f3.bg = "black"
f4 = Box(qt, width=100, height=400, grid=[4, 1])
f4.border = 1
f4.bg = "black"
f5 = Box(qt, width=100, height=400, grid=[5, 1])
f5.border = 1
f5.bg = "black"
f6 = Box(qt, width=100, height=400, grid=[6, 1])
f6.border = 1
f6.bg = "black"
f7 = Box(qt, width=100, height=400, grid=[7, 1])
f7.border = 1
f7.bg = "black"
f8 = Box(qt, width=100, height=400, grid=[8, 1])
f8.border = 1
f8.bg = "black"
bl = [f1, f3, f5, f7]
x = 0
for i in range(1, randint(1, 4)):
bl[i - 1].bg = "yellow"
x = i
print(x)
qt.update()
sleep(7.35478205493597)
f1.visible = False
f2.visible = False
f3.visible = False
f4.visible = False
f5.visible = False
f6.visible = False
f7.visible = False
f8.visible = False
bo2 = Box(qt, width=800, height=80, grid=[0, 1], layout="grid")
bo2.border = 1
b2pp = Box(qt, width=790, height=100, layout="grid", grid=[0, 2])
b2pp.border = 1
questiotwo = Text(qt,
text="How many yellow lines were there?",
grid=[0, 0])
questiotwo.text_size = 38
answer1 = PushButton(b2pp,
grid=[0, 2],
command=checknumber,
height=2,
width=9,
text="One")
answer1.text_size = 21
answer1.bg = 'red'
answer1.update_command(checknumber, args=['1', x])
answer2 = PushButton(b2pp,
grid=[1, 2],
command=checknumber,
height=2,
width=9,
text="Two")
answer2.text_size = 21
answer2.bg = 'orange'
answer2.update_command(checknumber, args=['2', x])
answer3 = PushButton(b2pp,
grid=[2, 2],
command=checknumber,
height=2,
width=9,
text="Three")
answer3.text_size = 21
answer3.bg = 'yellow'
answer3.update_command(checknumber, args=['3', x])
answer4 = PushButton(b2pp,
grid=[3, 2],
command=checknumber,
height=2,
width=9,
text="Four")
answer4.text_size = 21
answer4.bg = 'green'
answer4.update_command(checknumber, args=['4', x])
answer5 = PushButton(b2pp,
grid=[0, 3],
command=checknumber,
height=2,
width=9,
text="Five")
answer5.text_size = 21
answer5.bg = 'brown'
answer5.update_command(checknumber, args=['5', x])
answer6 = PushButton(b2pp,
grid=[1, 3],
command=checknumber,
height=2,
width=9,
text="Six")
answer6.text_size = 21
answer6.bg = 'grey'
answer6.update_command(checknumber, args=['6', x])
answer7 = PushButton(b2pp,
grid=[2, 3],
command=checknumber,
height=2,
width=9,
text="Zero")
answer7.text_size = 21
answer7.bg = 'purple'
answer7.update_command(checknumber, args=['0', x])
answer8 = PushButton(b2pp,
grid=[3, 3],
command=checknumber,
height=2,
width=9,
text="Dunno")
answer8.text_size = 21
answer8.bg = 'blue'
answer8.update_command(checknumber, args=['7', x])
timelimit = time()
# print('Running without sound')
# <<<<<<<<< RUN >>>>>>>>> #
atexit.register(exit_function)
print('Starting Function')
eqOn.when_clicked = change_earthquake_text
eqOff.when_clicked = change_earthquake_text
ctrOn.when_clicked = change_control_text
ctrOff.when_clicked = change_control_text
# feedback is handled using pickle
try:
with open('feedback.pkl','rb') as f:
feedback = pickle.load(f)
feedback.append([0,0])
except FileNotFoundError:
feedback = [[0,0]]
with open('feedback.pkl','wb') as f:
pickle.dump(feedback,f)
countFeedback()
adminWindow.show()
control_app.display() # show the app
stream.stop_stream()
p.terminate()
print('now at bottom of program')
# time.sleep(60);
class Gui(object):
def __init__(self):
self.dispenser = TestDispenser()
self.cup_number = 0
self.half_cup_number = 0
self.eighth_cup_number = 0
self.teaspoon_number = 0
self.dispensing_id = Ingredient.SALT # Default: id is salt (0)
self.dispensing_id_text = SALT_DISPENSING_TEXT # Default: salt
self.dispensing_amount = 0
self.dispensing_flag = False
self.app = App(title="Pestle Co.")
# All code must be added in th event loop
# START
# Set up the option window and hide it for now
self.option_window = Window(self.app, title="Choosing a spice")
self.option_window.hide() # hide this window for now
# Set up the dispensing window and hide it for now
self.dispensing_window = Window(self.option_window, title="Dispensing")
self.dispensing_window.hide() # hide this window for now
# Set up the welcome window
#self.app.set_full_screen()
self.welcome_message = Text(self.app,
text="Pestle Co.",
size=70,
font="Times New Roman",
color="blue")
self.start_button = PushButton(self.app,
command=self.open_option_window,
text="Push to Start",
width=20,
height=5)
self.start_button.text_color = (205, 133, 0)
self.start_button.text_size = 30
# Option page/window set up
# Salt button
self.salt_button = PushButton(self.option_window,
command=self.open_salt_dispensing_window,
text="Salt",
align="top",
width=10,
height=2)
self.salt_button.text_color = (205, 133, 0)
self.salt_button.text_size = 20
# Flour button
self.flour_button = PushButton(
self.option_window,
command=self.open_flour_dispensing_window,
text="Flour",
align="top",
width=10,
height=2)
self.flour_button.text_color = (205, 133, 0)
self.flour_button.text_size = 20
# Sugar button
self.sugar_button = PushButton(
self.option_window,
command=self.open_sugar_dispensing_window,
text="Sugar",
align="top",
width=10,
height=2)
self.sugar_button.text_color = (205, 133, 0)
self.sugar_button.text_size = 20
# Done button
self.done_button = PushButton(self.option_window,
command=self.close_option_window,
text="Done",
align="bottom",
width=10,
height=2)
self.done_button.text_color = (205, 133, 0)
self.done_button.text_size = 20
# Dispensing page/window set up
self.dispensing_text = Text(self.dispensing_window,
text=self.dispensing_id_text)
self.cup_button = PushButton(self.dispensing_window,
command=self.add_a_cup,
text="Cup")
self.cup_number_text = Text(self.dispensing_window,
text=str(self.cup_number) + " Cups(s)")
self.cup_button.text_color = (205, 133, 0)
self.cup_button.text_size = 20
self.half_cup_button = PushButton(self.dispensing_window,
command=self.add_a_half_cup,
text="Half Cup")
self.half_cup_number_text = Text(self.dispensing_window,
text=str(self.half_cup_number) +
" Half_cup(es)")
self.half_cup_button.text_color = (205, 133, 0)
self.half_cup_button.text_size = 20
self.eighth_cup_button = PushButton(self.dispensing_window,
command=self.add_a_eighth_cup,
text="Eighth_cup")
self.eighth_cup_number_text = Text(self.dispensing_window,
text=str(self.eighth_cup_number) +
" Eighth_cup(es)")
self.eighth_cup_button.text_color = (205, 133, 0)
self.eighth_cup_button.text_size = 20
self.teaspoon_button = PushButton(self.dispensing_window,
command=self.add_a_teaspoon,
text="Teaspoon")
self.teaspoon_number_text = Text(self.dispensing_window,
text=str(self.teaspoon_number) +
" Teaspoon(s)")
self.teaspoon_button.text_color = (205, 133, 0)
self.teaspoon_button.text_size = 20
self.dispense_button = PushButton(self.dispensing_window,
command=self.final_dispense,
text="Dispense",
align="bottom")
self.reset_button = PushButton(self.dispensing_window,
command=self.reset_measurement,
text="Reset",
align="bottom")
# STOP
print("here")
self.app.display()
# Helper functions: windows
def open_option_window(self):
self.option_window.show(wait=True)
#self.option_window.set_full_screen()
def close_option_window(self):
self.option_window.exit_full_screen()
self.option_window.hide()
self.app.display()
def open_dispensing_window(self):
self.dispensing_window.show(wait=True)
#self.dispensing_window.set_full_screen()
def close_dispensing_window(self):
self.dispensing_window.exit_full_screen()
self.dispensing_window.hide()
self.open_option_window()
def open_salt_dispensing_window(self):
self.dispensing_id_text = SALT_DISPENSING_TEXT
self.dispensing_text.clear()
self.dispensing_text.append(self.dispensing_id_text)
self.dispensing_id = Ingredient.SALT
self.open_dispensing_window()
def open_flour_dispensing_window(self):
self.dispensing_id_text = FLOUR_DISPENSING_TEXT
self.dispensing_text.clear()
self.dispensing_text.append(self.dispensing_id_text)
self.dispensing_id = Ingredient.FLOUR
self.open_dispensing_window()
def open_sugar_dispensing_window(self):
self.dispensing_id_text = SUGAR_DISPENSING_TEXT
self.dispensing_text.clear()
self.dispensing_text.append(self.dispensing_id_text)
self.dispensing_id = Ingredient.SUGAR
self.open_dispensing_window()
def add_dispensing_amount(self, dispensing_id, unit):
grams_per_cup = GRAMS_SALT_PER_CUP # default
conversion_per_cup = CUPS_PER_CUP # default
if dispensing_id == Ingredient.SALT:
grams_per_cup = GRAMS_SALT_PER_CUP
elif dispensing_id == Ingredient.FLOUR:
grams_per_cup = GRAMS_FLOUR_PER_CUP
elif dispensing_id == Ingredient.SUGAR:
grams_per_cup = GRAMS_SUGAR_PER_CUP
if unit == Unit.CUP:
conversion_per_cup = CUPS_PER_CUP
elif unit == Unit.HALF_CUP:
conversion_per_cup = HALF_CUPS_PER_CUP
elif unit == Unit.FOURTH_CUP:
conversion_per_cup = FOURTH_CUPS_PER_CUP
elif unit == Unit.EIGHTH_CUPS:
conversion_per_cup = EIGHTH_CUPS_PER_CUP
elif unit == Unit.TEASPOON:
conversion_per_cup = TEASPOON_PER_CUP
self.dispensing_amount += grams_per_cup / conversion_per_cup
# Helper functions: dispensing
def add_a_cup(self):
self.cup_number += 1
self.cup_number_text.clear()
self.cup_number_text.append(str(self.cup_number) + " Cup(s)")
self.add_dispensing_amount(self.dispensing_id, Unit.CUP)
def add_a_half_cup(self):
self.half_cup_number += 1
self.half_cup_number_text.clear()
self.half_cup_number_text.append(
str(self.half_cup_number) + " Half Cup(s)")
self.add_dispensing_amount(self.dispensing_id, Unit.HALF_CUP)
def add_a_eighth_cup(self):
self.eighth_cup_number += 1
self.eighth_cup_number_text.clear()
self.eighth_cup_number_text.append(
str(self.eighth_cup_number) + " Eighth Cup(s)")
self.add_dispensing_amount(self.dispensing_id, Unit.EIGHTH_CUPS)
def add_a_teaspoon(self):
self.teaspoon_number += 1
self.teaspoon_number_text.clear()
self.teaspoon_number_text.append(
str(self.teaspoon_number) + " Teaspoon(s)")
self.add_dispensing_amount(self.dispensing_id, Unit.TEASPOON)
def ready_to_dispense(self):
return self.dispensing_flag
def get_slot_id(self):
print(self.dispensing_id)
if (self.dispensing_id == Ingredient.SALT):
return 0
if (self.dispensing_id == Ingredient.FLOUR):
return 1
if (self.dispensing_id == Ingredient.SUGAR):
return 2
#return 0
def get_amount_in_grams(self):
return self.dispensing_amount
def reset_measurement(self):
self.dispensing_amount = 0
self.cup_number = 0
self.cup_number_text.clear()
self.cup_number_text.append(str(self.cup_number) + " Cup(s)")
self.half_cup_number = 0
self.half_cup_number_text.clear()
self.half_cup_number_text.append(
str(self.half_cup_number) + " Half Cup(s)")
self.eighth_cup_number = 0
self.eighth_cup_number_text.clear()
self.eighth_cup_number_text.append(
str(self.eighth_cup_number) + " Eighth Cup(s)")
self.teaspoon_number = 0
self.teaspoon_number_text.clear()
self.teaspoon_number_text.append(
str(self.teaspoon_number) + " Teaspoon(s)")
def final_dispense(self):
print("in final")
self.dispensing_flag = True
self.dispenser.dispense(self.get_slot_id(), self.dispensing_amount)
self.reset_measurement()
self.close_dispensing_window() # Return to the dispensing window
self.open_option_window() # Return to the option window
class SATCOM:
def __init__(self):
self.app = App(title="SATCOM", width=500, height=300, layout="grid")
self.app.on_close(self.on_close)
Text(self.app, text="Welcome to SATCOM", grid=[0, 0])
self.satcom_time = Text(self.app,
text="SATCOM Time: UNKNOWN",
grid=[1, 0])
self.satcom_time.text_color = "blue"
Text(self.app, text="Satelite Connection Status: ", grid=[0, 1])
self.satelite_status = Text(self.app, text="UNKNOWN", grid=[1, 1])
self.satelite_status.text_color = "blue"
Text(self.app, text="Satelite Messages: ", grid=[0, 2])
self.satelite_msg = Text(self.app, text="0", grid=[1, 2])
self.satelite_msg.text_color = "blue"
Text(self.app, text="Current GPS Coordinates: ", grid=[0, 3])
self.gps = Text(self.app, text="UNKNOWN", grid=[1, 3])
self.gps.text_color = "blue"
Text(self.app, text="Temp: ", grid=[0, 4])
self.temp = Text(self.app, text="UNKNOWN", grid=[1, 4])
self.temp.text_color = "blue"
Text(self.app, text="Pressure: ", grid=[0, 5])
self.pressure = Text(self.app, text="UNKNOWN", grid=[1, 5])
self.pressure.text_color = "blue"
Text(self.app, text="Humidity: ", grid=[0, 6])
self.humidity = Text(self.app, text="UNKNOWN", grid=[1, 6])
self.humidity.text_color = "blue"
Text(self.app, text="Altitude: ", grid=[0, 7])
self.altitude = Text(self.app, text="UNKNOWN", grid=[1, 7])
self.altitude.text_color = "blue"
self.send_message_window = Window(self.app,
title="Send Message",
width=400,
height=80,
layout="grid")
Text(self.send_message_window, text="Message: ", grid=[0, 0])
self.message_box = TextBox(self.send_message_window,
width=30,
grid=[1, 0])
PushButton(self.send_message_window,
text="Send",
command=self.send_message,
grid=[2, 0])
self.send_message_window.hide()
self.messages_window = Window(self.app,
title="Messages",
width=400,
height=300)
Text(self.messages_window, text="Messages")
self.message_list = ListBox(self.messages_window)
self.message_list.width = 40
self.message_list.height = 15
self.messages_window.hide()
PushButton(self.app,
text="Send Messages",
command=self.show_send_message,
grid=[0, 8])
PushButton(self.app,
text="Check Messages",
command=self.show_messages,
grid=[1, 8])
def on_close(self):
self.clock.cancel()
self.app.destroy()
def show(self):
self.clock = clock(1, self.get_data)
self.app.display()
def get_data(self):
try:
resp = requests.get(url="http://localhost:3939/status")
data = resp.json()
self.gps.value = "lat: %s lng: %s" % (data['gps']['lat'],
data['gps']['lng'])
if data['gps']['lat'] == 'NOT FIXED' or data['gps']['lat'] == -1:
self.gps.text_color = "red"
else:
self.gps.text_color = "green"
self.satcom_time.value = "SATCOM Time: %s" % data['satcom']['time']
self.satelite_status.value = data['satcom']['status']
if data['satcom']['status'] == 'ACQUIRING':
self.satelite_status.text_color = "red"
else:
self.satelite_status.text_color = "green"
self.satelite_msg.value = len(data['unread'])
if len(data['unread']) != 0:
self.satelite_msg.text_color = "red"
else:
self.satelite_msg.text_color = "green"
self.temp.value = data['sensors']['temperature']
if data['sensors']['temperature'] == -1:
self.temp.text_color = "red"
else:
self.temp.text_color = "green"
self.pressure.value = data['sensors']['pressure']
if data['sensors']['pressure'] == -1:
self.pressure.text_color = "red"
else:
self.pressure.text_color = "green"
self.humidity.value = data['sensors']['humidity']
if data['sensors']['humidity'] == -1:
self.humidity.text_color = "red"
else:
self.humidity.text_color = "green"
self.altitude.value = data['sensors']['altitude']
if data['sensors']['altitude'] == -1:
self.altitude.text_color = "red"
else:
self.altitude.text_color = "green"
except:
print("Connection failed")
def send_message(self):
pass
def show_send_message(self):
self.send_message_window.show()
def show_messages(self):
self.messages_window.show()
