def next_state():
global PHASE, CURRENT_TIME, LIMIT,days, sound_str, YOU_SELECTED_WAV, picked_day,picked_hour,picked_minutes
# Transition to Hour phase
if PHASE == 0:
# Get and combine selected day to announce to user
day = day_path + days[CURRENT_TIME] + "_f.wav"
sound.combine_wav_files(sound_str, YOU_SELECTED_WAV,day,nav_path+"Set_hour_f.wav")
picked_day = day
PHASE = 1
CURRENT_TIME = 0
LIMIT = 24
sound.Play(sound_str)
# Transition to Minute phase
elif PHASE == 1:
# Get and combine selected hour and announce to user
selected_hour = get_hour(CURRENT_TIME)
sound.combine_wav_files(sound_str,YOU_SELECTED_WAV,selected_hour,nav_path + "Set_minutes_f.wav")
picked_hour = CURRENT_TIME
PHASE = 2
CURRENT_TIME = 0
LIMIT = 60
sound.Play(sound_str)
# Transition to End phase
elif PHASE == 2:
selected_minutes = get_minutes(CURRENT_TIME)
picked_minutes = selected_minutes
get_final_time(picked_day,picked_hour,picked_minutes)
PHASE = 3
return 1
return 0
def setMin(self, select, k, j):
if (select == -1):
select = 59
j = 58
k = 0
elif (select == self.min_limit):
select = 0
k = 1
j = 59
if (k == self.min_limit):
k = 0
if (j == -1):
j = 59
self.current_min = select
# Need to check if single digit because wav file require "0" in front of number
if (select < 10):
self.selection["text"] = str(select)
self.k_index["text"] = str(k)
self.j_index["text"] = str(j)
sound.combine_wav_files(self.time_sound,
num_path + "0" + str(select) + "_f.wav")
sound.Play(self.time_sound)
self.min_selection = "0" + str(
self.current_min) # Set final min_selection
elif (select >= 10):
self.selection["text"] = str(select)
self.k_index["text"] = str(k)
self.j_index["text"] = str(j)
sound.combine_wav_files(self.time_sound,
num_path + str(select) + "_f.wav")
sound.Play(self.time_sound)
self.min_selection = str(self.current_min)
def play_current_minute(self):
# Minute selected is zero, play 'oh oh'
if (self._minute == 0):
sound.combine_wav_files(self.TMP_FILE_WAV, self.OH_WAV, self.OH_WAV)
sound.Play(self.TMP_FILE_WAV)
# Minute selected is 1-9, play 'oh' followed by the minute
elif ((self._minute * 5) <= 9):
sound.combine_wav_files(self.TMP_FILE_WAV, self.OH_WAV, self.TIME_WAV_DIR + \
str("{:02}".format(self._minute * 5)) + "_f.wav")
sound.Play(self.TMP_FILE_WAV)
# Minute selected is 11-59, simply play corresponding file
else:
sound.Play(self.TIME_WAV_DIR + str(self._minute * 5) + "_f.wav")
def play_current_minute(minute):
# Minute selected is zero, play 'oh oh'
if (minute == 0):
sound.combine_wav_files(TMP_FILE_WAV, OH_WAV, OH_WAV)
sound.Play(TMP_FILE_WAV)
# Minute selected is 1-9, play 'oh' followed by the minute
elif (minute >= 1 and minute <= 9):
sound.combine_wav_files(TMP_FILE_WAV, OH_WAV,
TIME_WAV_DIR + str(minute) + ".wav")
sound.Play(TMP_FILE_WAV)
# Minute selected is 11-59, simply play corresponding file
elif (minute >= 10 and minute <= 59):
sound.Play(TIME_WAV_DIR + str(minute) + ".wav")
def select(self, event):
if self.location[0] == 0:
if self.location[1] == 3:
self.myRoot.destroy()
self.hl(self.UIlist[self.location[0]][self.location[1]])
self.memory[0] = self.location
self.location = self.memory[self.location[1] + 1]
self.mark(self.UIlist[self.location[0]][self.location[1]])
if self.location[0] == 2:
if self.location[1] < 12:
sound.combine_wav_files(self.specialsounds[0],
self.sounds[2][self.location[1]],
self.specialsounds[2])
sound.Play(self.specialsounds[0])
else:
sound.combine_wav_files(self.specialsounds[0],
self.sounds[2][self.location[1]],
self.specialsounds[3])
sound.Play(self.specialsounds[0])
else:
sound.Play(self.sounds[self.location[0]][self.location[1]])
else:
self.hl(self.UIlist[self.location[0]][self.location[1]])
self.memory[self.location[0]] = self.location
selection = self.location
self.location = self.memory[0]
self.mark(self.UIlist[self.location[0]][self.location[1]])
if selection[0] == 2:
if selection[1] < 12:
sound.combine_wav_files(self.specialsounds[0],
self.specialsounds[1],
self.sounds[2][selection[1]],
self.specialsounds[2],
self.sounds[0][self.location[1]])
else:
sound.combine_wav_files(self.specialsounds[0],
self.specialsounds[1],
self.sounds[2][selection[1]],
self.specialsounds[3],
self.sounds[0][self.location[1]])
sound.Play(self.specialsounds[0])
else:
sound.combine_wav_files(
self.specialsounds[0], self.specialsounds[1],
self.sounds[selection[0]][selection[1]],
self.sounds[0][self.location[1]])
sound.Play(self.specialsounds[0])
self.update()
def play_help(state):
if (state == 0):
# User in weekday state, precede help message with 'Set day of week'
sound.combine_wav_files(TMP_FILE_WAV, SET_WEEKDAY_WAV, HELP_WAV)
elif (state == 1):
# User in hour state, precede help message with 'Set hour'
sound.combine_wav_files(TMP_FILE_WAV, SET_HOUR_WAV, HELP_WAV)
elif (state == 2):
# User in minute state, precede help message with 'Set minute'
sound.combine_wav_files(TMP_FILE_WAV, SET_MINUTE, HELP_WAV)
elif (state == 3):
# User in AM/PM state, plays 'Set AM PM'
sound.combine_wav_files(TMP_FILE_WAV, SET_AM_PM, HELP_WAV)
else:
# Otherwise, just play help message by itself
sound.combine_wav_files(TMP_FILE_WAV, HELP_WAV)
sound.Play(TMP_FILE_WAV) # Play full help message
def backward(self, event):
self.ll(self.UIlist[self.location[0]][self.location[1]])
self.location[1] -= 1
if self.location[1] == -1:
self.location[1] = len(self.UIlist[self.location[0]]) - 1
self.mark(self.UIlist[self.location[0]][self.location[1]])
if self.location[0] == 2:
if self.location[1] < 12:
sound.combine_wav_files(self.specialsounds[0],
self.sounds[2][self.location[1]],
self.specialsounds[2])
sound.Play(self.specialsounds[0])
else:
sound.combine_wav_files(self.specialsounds[0],
self.sounds[2][self.location[1]],
self.specialsounds[3])
sound.Play(self.specialsounds[0])
else:
sound.Play(self.sounds[self.location[0]][self.location[1]])
def verify_sound_filenames():
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
sound.Play(EXITING_PROGRAM_WAV)
sound.Play(YOU_SELECTED_WAV)
for x in range(60):
sound.Play(NUMBERS_WAV[x])
for x in range(7):
sound.Play(WEEKDAYS_WAV[x])
sound.Play(SET_DAY_OF_WEEK_WAV)
sound.Play(SET_HOUR_WAV)
sound.Play(SET_MINUTES_WAV)
sound.Play(OH_WAV)
sound.Play(O_CLOCK_WAV)
sound.Play(SET_DATE_AND_TIME_WAV)
# First sound we want is a concatenation
sound.combine_wav_files(TMP_FILE_WAV,
SET_DATE_AND_TIME_WAV,
SET_DAY_OF_WEEK_WAV,
WEEKDAYS_WAV[0])
sound.Play(TMP_FILE_WAV)
def play_result_and_quit():
#End of selection process, program will now repeat back all selections
#Top of the hour, disregard minute
if CURRENT_MINUTE == 0:
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY], HOURS_WAV[CURRENT_HOUR],
AMPM_WAV[CURRENT_AMPM])
#Single digit minute, use OH_WAV
elif CURRENT_MINUTE >= 1 and CURRENT_MINUTE < 10:
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY], HOURS_WAV[CURRENT_HOUR],
OH_WAV, MINUTES_WAV[CURRENT_MINUTE],
AMPM_WAV[CURRENT_AMPM])
else:
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY], HOURS_WAV[CURRENT_HOUR],
MINUTES_WAV[CURRENT_MINUTE],
AMPM_WAV[CURRENT_AMPM])
sound.Play(TMP_FILE_WAV)
time.sleep(4.8)
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
def introduce_stage(stage):
if stage == 0:
# Stage is 'Set Day of Week'
sound.combine_wav_files(TMP_FILE_WAV,
SET_DATE_AND_TIME_WAV,
SET_DAY_OF_WEEK_WAV,
WEEKDAYS_WAV[TIME_VAL[0]])
elif stage == 1:
# Stage is 'Set Hour'
sound.combine_wav_files(TMP_FILE_WAV,
SET_HOUR_WAV,
NUMBERS_WAV[TIME_VAL[1]])
elif stage == 2:
# Stage is 'Set Minute'
sound.combine_wav_files(TMP_FILE_WAV,
SET_MINUTES_WAV,
NUMBERS_WAV[TIME_VAL[2]])
sound.Play(TMP_FILE_WAV)
def play_complete_time(day, hour, minute, is_AM):
# Checks which am/pm file to play; assigns to 'am.wav' or 'pm.wav'
am_pm_wav = PM_WAV
if is_AM:
am_pm_wav = AM_WAV
# If the minute is 0, play the hour followed by 'o clock'
# For example: 'Thursday, 12 o clock PM'
if (minute == 0):
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV, WEEKDAYS_WAV[day],\
TIME_WAV_DIR + str(hour) + ".wav", OH_CLOCK_WAV, am_pm_wav)
# Else if the minute is 1-9, play 'oh' before the minute
# For example: 'Thursday, 12 oh 5 PM'
elif (minute >= 1 and minute <= 9):
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV, WEEKDAYS_WAV[day],\
TIME_WAV_DIR + str(hour) + ".wav", OH_WAV,\
TIME_WAV_DIR + str(minute) + ".wav", am_pm_wav)
# Otherwise, play the corresponding numbered file (e.g. 34 plays '34.wav')
else:
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV, WEEKDAYS_WAV[day],\
TIME_WAV_DIR + str(hour) + ".wav", TIME_WAV_DIR + str(minute) + ".wav",\
am_pm_wav)
sound.Play(TMP_FILE_WAV) # Play the complete time file
def play_complete_time(self):
# Checks which am/pm file to play; assigns to 'am.wav' or 'pm.wav'
am_pm_wav = self.PM_WAV
if self._isAM:
am_pm_wav = self.AM_WAV
# If the minute is 0, play the hour followed by 'o clock'
# For example: 'Thursday, 12 o clock PM'
if (self._minute == 0):
sound.combine_wav_files(self.TMP_FILE_WAV, self.YOU_SELECTED_WAV, self.WEEKDAYS_WAV[self._day],\
self.TIME_WAV_DIR + str(self._hour + 1) + ".wav", self.OH_CLOCK_WAV, am_pm_wav)
# Else if the minute is 1-9, play 'oh' before the minute
# For example: 'Thursday, 12 oh 5 PM'
elif ((self._minute * 5) <= 9):
sound.combine_wav_files(self.TMP_FILE_WAV, self.YOU_SELECTED_WAV, self.WEEKDAYS_WAV[self._day],\
self.TIME_WAV_DIR + str(self._hour + 1) + ".wav", self.OH_WAV,\
self.TIME_WAV_DIR + str(self._minute * 5) + ".wav", am_pm_wav)
# Otherwise, play the corresponding numbered file (e.g. 34 plays '34.wav')
else:
sound.combine_wav_files(self.TMP_FILE_WAV, self.YOU_SELECTED_WAV, self.WEEKDAYS_WAV[self._day],\
self.TIME_WAV_DIR + str(self._hour + 1) + ".wav", self.TIME_WAV_DIR + str(self._minute * 5) + ".wav",\
am_pm_wav)
sound.Play(self.TMP_FILE_WAV) # Play the complete time file
def set_day():
global CURRENT_TIME
global CURRENT_DAY
CURRENT_TIME = 0
#Play the entering state audio
sound.Play(SET_DAY_WAV)
time.sleep(1.4)
#Play current day selection
sound.combine_wav_files(TMP_FILE_WAV, CURRENT_DAY_WAV,
DAYS_WAV[CURRENT_TIME])
sound.Play(TMP_FILE_WAV)
time.sleep(3)
# Get the first keystroke.
c = readchar.readchar()
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the SELECT_KEY or the QUIT_KEY
while True:
# Respond to the user's input.
if c == FORWARD_KEY:
# Advance the time, looping back around to the start.
CURRENT_TIME += 1
if CURRENT_TIME == len(DAYS_WAV):
CURRENT_TIME = 0
# Concatenate two audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, DAYS_WAV[CURRENT_TIME])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# Backward key
if c == BACKWARD_KEY:
# Move backward, looping around
CURRENT_TIME -= 1
if CURRENT_TIME == -1:
CURRENT_TIME = len(DAYS_WAV) - 1
# Concatenate two audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, DAYS_WAV[CURRENT_TIME])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# Selects current time
if c == SELECT_KEY:
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_TIME])
# Save the hour selection
CURRENT_DAY = CURRENT_TIME
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
time.sleep(2.8)
#Go to set hour state
set_hour()
break
#User presses help key
if c == HELP_KEY:
# Notify the user that another HELP_KEY will play the help menu
sound.Play(PRESS_AGAIN_FOR_HELP_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed HELP_KEY, play key options
if c == HELP_KEY:
sound.combine_wav_files(TMP_FILE_WAV, QUIT_WAV, HELP_WAV,
DOWN_WAV, UP_WAV, SELECT_WAV)
sound.Play(TMP_FILE_WAV)
# User quits.
if c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
# The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
def Right_Click(self, event):
report_event(event) ### (3)
event_time = str(event.time)
self.trial_data.append([event_time, event.char])
self.keyCount = self.keyCount + 1
if self.MM_Label["background"] == self.mm_HC:
if self.Set_Day["background"] == self.cursor_Col:
self.Set_Day["background"] = "#ffffff"
self.Set_Hour["background"] = self.cursor_Col
sound.Play(MISC_PATH + "Set_hour_f.wav")
elif self.Set_Hour["background"] == self.cursor_Col:
self.Set_Hour["background"] = "#ffffff"
self.Set_Min["background"] = self.cursor_Col
sound.Play(MISC_PATH + "Set_minute_f.wav")
elif self.Set_Min["background"] == self.cursor_Col:
self.Set_Min["background"] = "#ffffff"
self.Reset["background"] = self.cursor_Col
sound.Play("extra_wav/reset.wav")
elif self.Reset["background"] == self.cursor_Col:
self.Reset["background"] = "#ffffff"
self.Set_Day["background"] = self.cursor_Col
sound.Play(MISC_PATH + "Set_day_f.wav")
elif self.Set_Day["background"] == self.mm_HC:
self.D_LEFT["text"] = self.D_MID["text"]
self.D_MID["text"] = self.D_RIGHT["text"]
if self.D_RIGHT["text"] == "Monday":
self.D_RIGHT["text"] = "Tuesday"
sound.Play(DAYS_PATH + "monday_f.wav")
elif self.D_RIGHT["text"] == "Tuesday":
self.D_RIGHT["text"] = "Wednesday"
sound.Play(DAYS_PATH + "tuesday_f.wav")
elif self.D_RIGHT["text"] == "Wednesday":
self.D_RIGHT["text"] = "Thursday"
sound.Play(DAYS_PATH + "wednesday_f.wav")
elif self.D_RIGHT["text"] == "Thursday":
self.D_RIGHT["text"] = "Friday"
sound.Play(DAYS_PATH + "thursday_f.wav")
elif self.D_RIGHT["text"] == "Friday":
self.D_RIGHT["text"] = "Saturday"
sound.Play(DAYS_PATH + "friday_f.wav")
elif self.D_RIGHT["text"] == "Saturday":
self.D_RIGHT["text"] = "Sunday"
sound.Play(DAYS_PATH + "saturday_f.wav")
elif self.D_RIGHT["text"] == "Sunday":
self.D_RIGHT["text"] = "Monday"
sound.Play(DAYS_PATH + "sunday_f.wav")
# self.D_RIGHT.config(relief=tk.SUNKEN, background=self.cursor_Col)
# self.D_RIGHT.after(150, lambda: self.D_RIGHT.config(relief=tk.SOLID, background="#ffffff"))
elif self.Set_Hour["background"] == self.mm_HC:
for i in range(0,len(self.hour_ARR)):
if self.hour_ARR[i] == 23:
self.hour_ARR[i] = 0
else:
self.hour_ARR[i] = self.hour_ARR[i] + 1
self.H_LEFT["text"] = self.hour_Str_ampm(self.hour_ARR[0])
self.H_RIGHT["text"] = self.hour_Str_ampm(self.hour_ARR[2])
# index 2 goes last to ensure consistent am-pm with user chouice
self.H_MID["text"] = self.hour_Str_ampm(self.hour_ARR[1])
sound.combine_wav_files(self.TMP_WAV, NUM_PATH + self.hour_Str(self.hour_ARR[1]) + '_f.wav', MISC_PATH + self.ampm + '_f.wav')
sound.Play(self.TMP_WAV)
# self.H_RIGHT.config(relief=tk.SUNKEN, background=self.cursor_Col)
# self.H_RIGHT.after(150, lambda: self.H_RIGHT.config(relief=tk.SOLID, background="#ffffff"))
elif self.Set_Min["background"] == self.mm_HC:
for i in range(0,len(self.min_ARR)):
if self.min_ARR[i] == 59:
self.min_ARR[i] = 0
else:
self.min_ARR[i] = self.min_ARR[i] + 1
self.M_LEFT["text"] = self.min_Str(self.min_ARR[0])
self.M_RIGHT["text"] = self.min_Str(self.min_ARR[2])
# index 2 goes last to ensure consistent am-pm with user chouice
self.M_MID["text"] = self.min_Str(self.min_ARR[1])
sound.Play(NUM_PATH + self.min_Str(self.min_ARR[1]) + '_f.wav')
# self.M_RIGHT.config(relief=tk.SUNKEN, background=self.cursor_Col)
# self.M_RIGHT.after(150, lambda: self.M_RIGHT.config(relief=tk.SOLID, background="#ffffff"))
self.button2.config(relief=tk.SUNKEN, background=self.cursor_Col)
self.button2.after(150, lambda: self.button2.config(relief=tk.SOLID, background="#ffffff"))
def run_menu():
global CURRENT_TIME
global CURRENT_DAY
global CURRENT_HOUR
global CURRENT_MINUTE
#boolean for switching from days to hours
days_selection = True
#boolean for switching from hours to minutes if a developer should extend program for minutes
hour_selection = False
#booleans for switching from am to pm
am = True
pm = False
# Provide a minimal indication that the program has started.
print(MINIMAL_HELP_STRING)
# Indicate program has started and list options for user
sound.Play(INTRO_WAV)
# Get the first keystroke.
c = readchar.readchar()
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the QUIT_MENU_KEY or SET_KEY the second time.
while True:
#this now should loop though days
if c == BACKWARD_KEY and days_selection == True:
if CURRENT_DAY == 0:
CURRENT_DAY = len(DAYS_WAV)-1
else:
CURRENT_DAY -= 1
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# Respond to the user's input. If the day selection is true
# means if the user has not yet selected a day.
if c == FORWARD_KEY and days_selection == True:
# Advance the time, looping back around to the start.
CURRENT_DAY += 1
if CURRENT_DAY == len(DAYS_WAV):
CURRENT_DAY = 0
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# repeat intro if the user hasnt set the day yet
if c == REPEAT_KEY and days_selection == True:
sound.Play(INTRO_WAV)
# repeat set time instruction if days have been selected
if c == REPEAT_KEY and days_selection == False:
sound.Play(SET_HOUR_WAV)
# this now should loop though hours
# since day selection is false the user already selected a day.
if c == BACKWARD_KEY and days_selection == False:
# boolean variable for converting am to pm and vice versa
convert = False
if CURRENT_TIME == 0:
CURRENT_TIME = 11
# change from am to pm or vice versa
convert = True
else:
CURRENT_TIME -= 1
#configure am and pm
if(convert):
if am == True:
am = False
pm = True
convert = False
else:
am = True
pm = False
convert = False
if am == True:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_TIME], AM_WAV)
else:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_TIME], PM_WAV)
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# selecting hour
if c == FORWARD_KEY and days_selection == False:
# variable for converting am to pm and vice versa
convert = False
# Advance the time, looping back around to the start.
if (CURRENT_TIME) > 10:
CURRENT_TIME = 0
# change from am to pm or vice versa
convert = True
else:
CURRENT_TIME += 1
#configure am and pm
if(convert):
if am == True:
am = False
pm = True
convert = False
else:
am = True
pm = False
convert = False
if am == True:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_TIME], AM_WAV)
else:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_TIME], PM_WAV)
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
if c == SET_KEY:
# second time being pressed
if days_selection == False:
# audio recognition of hours being selected
sound.Play(HOUR_SET_WAV)
# pause to play next sound
time.sleep(PAUSING_BETWEEN_AUDIO_FILE_DURATION)
# informing exit
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
else:
# disable day conditions
days_selection = False
sound.Play(DAY_SET_WAV)
time.sleep(PAUSING_BETWEEN_AUDIO_FILE_DURATION)
#indicate switch from days to hours
sound.Play(SET_HOUR_WAV)
#listen for user input
c = readchar.readchar()
# User quits.
if c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
# The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
def run_menu():
global CURRENT_MINUTE, CURRENT_HOUR, CURRENT_DAY
# Provide a minimal indication that the program has started.
print(MINIMAL_HELP_STRING)
# Get the first keystroke.
c = readchar.readchar()
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the QUIT_MENU_KEY.
while True:
# Respond to the user's input.
if c == START_KEY:
CURRENT_DAY = 0
CURRENT_HOUR = 1
CURRENT_MINUTE = 0
#Print the set of instructions for setting the day
print(BACKWARD_AND_FORWARD_INSTRUCTIONS_DAY)
sound.Play(SELECT_DAY_OF_THE_WEEK)
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.Play(DAYS_OF_WEEK_WAV[CURRENT_DAY])
c = readchar.readchar()
# Following loop allows the user to choose the day, it breaks when the user presses the SET_KEY
while True:
if c == FORWARD_KEY: #increments or resets the current_day value
if CURRENT_DAY != 6:
CURRENT_DAY += 1
else:
CURRENT_DAY = 0
sound.Play(DAYS_OF_WEEK_WAV[CURRENT_DAY])
c = readchar.readchar()
elif c == BACKWARD_KEY: #decrements or resets the current_day value
if CURRENT_DAY != 0:
CURRENT_DAY -= 1
else:
CURRENT_DAY = 6
sound.Play(
DAYS_OF_WEEK_WAV[CURRENT_DAY]
) #plays the sound file corresponding to the index of array containing the day of the week sound files
c = readchar.readchar()
elif c == SET_KEY:
break
else:
# Get the user's next keystroke.
c = readchar.readchar()
#end while
#Print the set of instructions for setting the hour
print(BACKWARD_AND_FORWARD_INSTRUCTIONS_HOUR)
sound.Play(SET_HOUR)
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.Play(NUMBERS_WAV[CURRENT_HOUR])
c = readchar.readchar()
#The following loop is for setting hour, the hours ranges from 0-23, it exits the loop by pressing 'set' or 'quit.'
while True:
if c == FORWARD_KEY:
if CURRENT_HOUR != 23:
CURRENT_HOUR += 1
else:
CURRENT_HOUR = 0
sound.Play(NUMBERS_WAV[CURRENT_HOUR])
c = readchar.readchar()
elif c == BACKWARD_KEY:
if CURRENT_HOUR != 0:
CURRENT_HOUR -= 1
else:
CURRENT_HOUR = 23
sound.Play(NUMBERS_WAV[CURRENT_HOUR])
c = readchar.readchar()
elif c == SET_KEY:
break
else:
c = readchar.readchar()
#end while
#Print the set of instructions for setting the minutes
print(BACKWARD_AND_FORWARD_INSTRUCTIONS_MINS)
sound.Play(SET_MIN)
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.Play(NUMBERS_WAV[CURRENT_MINUTE])
c = readchar.readchar()
#The following loop is for setting minutes, the minutes ranges from 0-59, it exits the loop by pressing 'set' or 'quit.'
while True:
if c == FORWARD_KEY:
if CURRENT_MINUTE != 59:
CURRENT_MINUTE += 1
else:
CURRENT_MINUTE = 0
sound.Play(NUMBERS_WAV[CURRENT_MINUTE])
c = readchar.readchar()
elif c == BACKWARD_KEY:
if CURRENT_MINUTE != 0:
CURRENT_MINUTE -= 1
else:
CURRENT_MINUTE = 59
sound.Play(NUMBERS_WAV[CURRENT_MINUTE])
c = readchar.readchar()
elif c == SET_KEY:
break
else:
c = readchar.readchar()
#if the time is in the AM
if CURRENT_HOUR <= 12:
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_OF_WEEK_WAV[CURRENT_DAY],
NUMBERS_WAV[CURRENT_HOUR],
NUMBERS_WAV[CURRENT_MINUTE], AM_WAV)
sound.Play(TMP_FILE_WAV)
# if the time is in the PM
if CURRENT_HOUR > 12:
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_OF_WEEK_WAV[CURRENT_DAY],
NUMBERS_WAV[CURRENT_HOUR - 12],
NUMBERS_WAV[CURRENT_MINUTE], PM_WAV)
sound.Play(TMP_FILE_WAV)
#Making the program sleep until the combined wav files is done being reported
time.sleep(EXITING_PROGRAM_WAV_DURATION)
time.sleep(EXITING_PROGRAM_WAV_DURATION)
time.sleep(EXITING_PROGRAM_WAV_DURATION)
time.sleep(EXITING_PROGRAM_WAV_DURATION)
#Intructions for starting over or exiting the program
sound.Play(INTRO_WAV)
print(MINIMAL_HELP_STRING)
c = readchar.readchar()
# User quits.
elif c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
# The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
def run_menu():
global CURRENT_TIME
global CURRENT_DAY
global CURRENT_HOUR
global CURRENT_MINUTE
#boolean for switching from days to hours
days_selection = True
#boolean for switching from hours to minutes if a developer should extend program for minutes
hour_selection = False
#booleans for switching from am to pm
am = True
pm = False
# Provide a minimal indication that the program has started.
print(MINIMAL_HELP_STRING)
# Indicate program has started and list options for user
sound.Play(INTRO_WAV)
# Get the first keystroke.
c = readchar.readchar()
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the QUIT_MENU_KEY or SET_KEY the second time.
while True:
#this now should loop though days
if c == BACKWARD_KEY and days_selection == True:
if CURRENT_DAY == 0:
CURRENT_DAY = len(DAYS_WAV) - 1
else:
CURRENT_DAY -= 1
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# Respond to the user's input. If the day selection is true
# means if the user has not yet selected a day.
if c == FORWARD_KEY and days_selection == True:
# Advance the time, looping back around to the start.
CURRENT_DAY += 1
if CURRENT_DAY == len(DAYS_WAV):
CURRENT_DAY = 0
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# repeat intro if the user hasnt set the day yet
if c == REPEAT_KEY and days_selection == True:
sound.Play(INTRO_WAV)
# repeat set time instruction if days have been selected
if c == REPEAT_KEY and days_selection == False:
sound.Play(SET_HOUR_WAV)
# this now should loop though hours
if c == BACKWARD_KEY and days_selection == False and hour_selection == True:
# boolean variable for converting am to pm and vice versa
convert = False
if CURRENT_HOUR <= 1:
CURRENT_HOUR = 12
# change from am to pm or vice versa
convert = True
else:
CURRENT_HOUR -= 1
# configure am and pm
if (convert):
if am == True:
am = False
pm = True
convert = False
else:
am = True
pm = False
convert = False
if am == True:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_HOUR], AM_WAV)
else:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_HOUR], PM_WAV)
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# selecting minute
if c == FORWARD_KEY and days_selection == False and hour_selection == False:
# advance the time, looping back around to the start.
if (CURRENT_MINUTE) > 58:
CURRENT_MINUTE = 0
# change from am to pm or vice versa
convert = True
else:
CURRENT_MINUTE += 1
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_MINUTE])
sound.Play(TMP_FILE_WAV)
# selecting minute
if c == BACKWARD_KEY and days_selection == False and hour_selection == False:
if CURRENT_MINUTE == 1:
CURRENT_MINUTE = 59
else:
CURRENT_MINUTE -= 1
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_MINUTE])
sound.Play(TMP_FILE_WAV)
# selecting hour
if c == FORWARD_KEY and days_selection == False and hour_selection == True:
# variable for converting am to pm and vice versa
convert = False
# Advance the time, looping back around to the start.
if (CURRENT_HOUR) > 11:
CURRENT_HOUR = 1
# change from am to pm or vice versa
convert = True
else:
CURRENT_HOUR += 1
#configure am and pm
if (convert):
if am == True:
am = False
pm = True
convert = False
else:
am = True
pm = False
convert = False
if am == True:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_HOUR], AM_WAV)
else:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_HOUR], PM_WAV)
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
if c == SET_KEY:
# second time being pressed
if hour_selection == True:
# so if day selection is false then program went through hour cycle already and came back
hour_selection = False
# audio recognition of hours being selected
sound.Play(HOUR_SET_WAV)
# pause between sounds
time.sleep(PAUSING_BETWEEN_AUDIO_FILE_DURATION_FASTER)
# indicate to set minutes
sound.Play(SET_MINUTES_WAV)
elif days_selection == True:
# disable day conditions
days_selection = False
hour_selection = True
sound.Play(DAY_SET_WAV)
# pause between sounds
time.sleep(PAUSING_BETWEEN_AUDIO_FILE_DURATION_FASTER)
#indicate switch from days to hours
sound.Play(SET_HOUR_WAV)
#listen for user input
c = readchar.readchar()
# minutes == true
elif days_selection == False and hour_selection == False:
if am == True:
# numbers starting at one and and ending at nine are pronounced: "number oh number" typically
# example: 1:10 = "one ten" whereas 1:09= "one oh nine"
if (CURRENT_MINUTE < 10 and CURRENT_MINUTE > 0):
# audio recognition of minutes being selected and result of all selections
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV,
DAYS_WAV[CURRENT_DAY],
NUMBERS_WAV[CURRENT_HOUR],
OH_WAV,
NUMBERS_WAV[CURRENT_MINUTE],
AM_WAV, EXITING_PROGRAM_WAV)
sound.Play(TMP_FILE_WAV)
# if the minutes are equal to zero then we should not say the minutes, example 1:00 = "1 am" or "1 pm"
elif (CURRENT_MINUTE == 0):
sound.combine_wav_files(TMP_FILE_WAV,
DAYS_WAV[CURRENT_DAY],
NUMBERS_WAV[CURRENT_HOUR],
AM_WAV)
sound.Play(TMP_FILE_WAV)
else:
# audio recognition of minutes being selected and result of all selections
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV,
DAYS_WAV[CURRENT_DAY],
NUMBERS_WAV[CURRENT_HOUR],
NUMBERS_WAV[CURRENT_MINUTE],
AM_WAV, EXITING_PROGRAM_WAV)
sound.Play(TMP_FILE_WAV)
# giving time for the current audio to finish playing before exiting program.
time.sleep(PAUSING_BETWEEN_AUDIO_FILE_DURATION_SLOWER)
quit_program()
# if pm is true and am is false
else:
# numbers starting at one and and ending at nine are pronounced: "number oh number" typically
# example: 1:10 = "one ten" whereas 1:09= "one oh nine"
if (CURRENT_MINUTE < 10 and CURRENT_MINUTE > 0):
# audio recognition of minutes being selected and result of all selections
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV,
DAYS_WAV[CURRENT_DAY],
NUMBERS_WAV[CURRENT_HOUR],
OH_WAV,
NUMBERS_WAV[CURRENT_MINUTE],
PM_WAV)
sound.Play(TMP_FILE_WAV)
# if the minutes are equal to zero then we should not say the minutes, example 1:00 = "1 am" or "1 pm"
elif (CURRENT_MINUTE == 0):
sound.combine_wav_files(TMP_FILE_WAV,
DAYS_WAV[CURRENT_DAY],
NUMBERS_WAV[CURRENT_HOUR],
AM_WAV)
sound.Play(TMP_FILE_WAV)
else:
# audio recognition of minutes being selected and result of all selections
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV,
DAYS_WAV[CURRENT_DAY],
NUMBERS_WAV[CURRENT_HOUR],
NUMBERS_WAV[CURRENT_MINUTE],
PM_WAV)
sound.Play(TMP_FILE_WAV)
# giving time for the current audio to finish playing before exiting program.
time.sleep(PAUSING_BETWEEN_AUDIO_FILE_DURATION_SLOWER)
quit_program()
# User quits.
if c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
# The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
def get_hour(time):
hour = "hour.wav"
# When time is 12 AM
if time == 0:
index = num_path + "12_f.wav"
sound.combine_wav_files(hour, index, AM_WAV)
sound.Play(hour)
# When time is 12 PM
elif time == 12:
index = num_path + "12_f.wav"
sound.combine_wav_files(hour, index, PM_WAV)
sound.Play(hour)
# When time is after 9 AM and before 12 PM
elif time > 9 and time < 12:
index = num_path + str(time) + "_f.wav"
sound.combine_wav_files(hour, index, AM_WAV)
sound.Play(hour)
# When time is after 12 AM and before 10 AM
elif time < 10 and time > 0:
index = num_path + "0" + str(time) + "_f.wav"
sound.combine_wav_files(hour, index, AM_WAV)
sound.Play(hour)
# When time is after 12 PM and before 10 PM
elif time > 12 and time < 22:
index = num_path + "0" + str(time - 12) + "_f.wav"
sound.combine_wav_files(hour, index, PM_WAV)
sound.Play(hour)
# When time is after 9 PM
elif time > 21:
index = num_path + str(time - 12) + "_f.wav"
sound.combine_wav_files(hour, index, PM_WAV)
sound.Play(hour)
return hour
def okButtonClick(self, event):
if (
self.edit_state == 0
): # Relay to user of the setting they chose before going opening edit menu
self.edit_state = 1
if (self.state_index == 0):
self.changeToEdit(self.edit_state, 0)
sound.combine_wav_files(self.temp_sound, YOU_SELECTED,
nav_path + "Set_day_of_week_f.wav")
sound.Play(self.temp_sound)
elif (self.state_index == 1):
self.changeToEdit(self.edit_state, 1)
sound.combine_wav_files(self.temp_sound, YOU_SELECTED,
nav_path + "Set_hour_f.wav")
sound.Play(self.temp_sound)
elif (self.state_index == 2):
self.changeToEdit(self.edit_state, 2)
sound.combine_wav_files(self.temp_sound, YOU_SELECTED,
nav_path + "Set_minutes_f.wav")
sound.Play(self.temp_sound)
elif (self.state_index == 3
): # User is done and wants to confirm their final time
# checking if minute is zero so o_clock.wav is played
if (self.current_min == 0):
sound.combine_wav_files(
self.temp_sound, my_sounds_path + "final_time.wav",
days_path + self.day_selection + "_f.wav",
num_path + self.hour_selection + "_f.wav",
nav_path + "o_clock_f.wav",
nav_path + self.ampm_selection + "_f.wav")
sound.Play(self.temp_sound)
time.sleep(
EXIT_TIME
) # Sleep so program has enough time to say final time
self.myParent.destroy() # before closing
# checking if single digit minute so that oh.wav is played before minute
elif (self.current_min < 10 and self.current_min > 0):
sound.combine_wav_files(
self.temp_sound, my_sounds_path + "final_time.wav",
days_path + self.day_selection + "_f.wav",
num_path + self.hour_selection + "_f.wav",
num_path + "oh_f.wav",
num_path + self.min_selection + "_f.wav",
nav_path + self.ampm_selection + "_f.wav")
sound.Play(self.temp_sound)
time.sleep(EXIT_TIME)
self.myParent.destroy()
# Any other minute will be played without any extra wav files
elif (self.current_min >= 10):
sound.combine_wav_files(
self.temp_sound, my_sounds_path + "final_time.wav",
days_path + self.day_selection + "_f.wav",
num_path + self.hour_selection + "_f.wav",
num_path + self.min_selection + "_f.wav",
nav_path + self.ampm_selection + "_f.wav")
sound.Play(self.temp_sound)
time.sleep(EXIT_TIME)
self.myParent.destroy()
elif (self.edit_state == 1): # When confirming an edit
if (self.state_index == 0): # Confirming an edit of the day
self.day_selection = self.days_list[self.current_day]
sound.combine_wav_files(
self.temp_sound, YOU_SELECTED,
days_path + self.days_list[self.current_day] + "_f.wav")
sound.Play(self.temp_sound)
elif (self.state_index == 1): # Confirming edit of hour
sound.combine_wav_files(
self.temp_sound, YOU_SELECTED,
num_path + self.hour_selection + "_f.wav",
nav_path + self.ampm_selection + "_f.wav")
sound.Play(self.temp_sound)
elif (self.state_index == 2): # Confirming edit of minute
sound.combine_wav_files(
self.temp_sound, YOU_SELECTED,
num_path + self.min_selection + "_f.wav")
sound.Play(self.temp_sound)
self.edit_state = 0
self.changeToEdit(
self.edit_state,
self.state_index) # Change back to main menu state
def setHour(self, select, k, j):
# Set base cases for when the index goes over or below the limit
if (select == -1):
select = 23
j = 22
k = 0
elif (select == self.hour_limit):
select = 0
k = 1
j = 23
if (k == self.hour_limit):
k = 0
if (j == -1):
j = 23
self.current_hour = select # Set the current hour to the new index
# Need to check if single digit because wav file requires "0" infornt of number
# Also need index above 12 to correspond to PM and below 12 to AM
if (select == 0): # 0 corresponds to 12 AM
self.selection["text"] = "12 AM"
sound.combine_wav_files(self.time_sound, num_path + "12_f.wav",
nav_path + "AM_f.wav")
sound.Play(self.time_sound)
self.hour_selection = "12" # set final hour_selection to selected hour
self.ampm_selection = "AM" # final AM or PM corresponds to index
elif (select == 12): # 12 PM
self.selection["text"] = "12 PM"
sound.combine_wav_files(self.time_sound, num_path + "12_f.wav",
nav_path + "PM_f.wav")
sound.Play(self.time_sound)
self.hour_selection = "12"
self.ampm_selection = "PM"
elif (select > 0 and select < 10): # Hours between 12 AM and 10 AM
self.selection["text"] = str(select) + " AM"
sound.combine_wav_files(self.time_sound,
num_path + "0" + str(select) + "_f.wav",
nav_path + "AM_f.wav")
sound.Play(self.time_sound)
self.hour_selection = "0" + str(select)
self.ampm_selection = "AM"
elif (select < 12 and select > 9): # Hours between 10 AM and 12 PM
self.selection["text"] = str(select) + " AM"
sound.combine_wav_files(self.time_sound,
num_path + str(select) + "_f.wav",
nav_path + "AM_f.wav")
sound.Play(self.time_sound)
self.hour_selection = str(select)
self.ampm_selection = "AM"
elif (select > 12 and select < 22): # Hours between 12 PM and 10 PM
self.selection["text"] = str(select - 12) + " PM"
sound.combine_wav_files(
self.time_sound, num_path + "0" + str(select - 12) + "_f.wav",
nav_path + "PM_f.wav")
sound.Play(self.time_sound)
self.hour_selection = "0" + str(select - 12)
self.ampm_selection = "PM"
elif (select > 21): # Hours between 10 PM and 12 AM
self.selection["text"] = str(select - 12) + " PM"
sound.combine_wav_files(self.time_sound,
num_path + str(select - 12) + "_f.wav",
nav_path + "PM_f.wav")
sound.Play(self.time_sound)
self.hour_selection = str(select - 12)
self.ampm_selection = "PM"
# Making sure the K and J labels correspond correctly to AM and PM
if (k == 0):
self.k_index["text"] = "12 AM"
elif (k == 12):
self.k_index["text"] = "12 PM"
elif (k < 12):
self.k_index["text"] = str(k) + " AM"
elif (k > 12):
self.k_index["text"] = str(k - 12) + " PM"
if (j == 0):
self.j_index["text"] = "12 AM"
elif (j == 12):
self.j_index["text"] = "12 PM"
elif (j < 12):
self.j_index["text"] = str(j) + " AM"
elif (j > 12):
self.j_index["text"] = str(j - 12) + " PM"
def run_fenu():
global CURRENT_TIME
global CURRENT_DAY
#boolean for switching from days to hours
days_selection = True
#boolean for switching from hours to minutes
hours_selection = False
#booleans for switching from am to pm
am = True
pm = False
# Provide a minimal indication that the program has started.
print(MINIMAL_HELP_STRING)
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, INTRO_WAV, SET_DAY_WAV)
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# Get the 2nd keystroke.
c = readchar.readchar()
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the QUIT_MENU_KEY or SET_KEY the second time.
while True:
#this now should loop though days
if c == BACKWARD_KEY and days_selection == True:
if CURRENT_DAY == 0:
CURRENT_DAY = len(DAYS_WAV)-1
else:
CURRENT_DAY -= 1
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# Respond to the user's input.
if c == FORWARD_KEY and days_selection == True:
# Advance the time, looping back around to the start.
CURRENT_DAY += 1
if CURRENT_DAY == len(DAYS_WAV):
CURRENT_DAY = 0
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
DAYS_WAV[CURRENT_DAY])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# this now should loop though hours
if c == BACKWARD_KEY and days_selection == False:
hours_selection = True
# variable for converting am to pm and vice versa
convert = False
if CURRENT_TIME == 0:
CURRENT_TIME = len(NUMBERS_WAV)-1
# change from am to pm or vice versa
convert = True
else:
CURRENT_TIME -= 1
print(CURRENT_TIME)
#configure am and pm
if(convert):
if am == True:
am = False
pm = True
convert = False
else:
am = True
pm = False
convert = False
if am == True:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_TIME], AM_WAV)
else:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_TIME], PM_WAV)
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
if c == FORWARD_KEY and days_selection == False:
hours_selection = True
# variable for converting am to pm and vice versa
convert = False
# Advance the time, looping back around to the start.
if (CURRENT_TIME+1) == len(NUMBERS_WAV):
CURRENT_TIME = 0
# change from am to pm or vice versa
convert = True
else:
CURRENT_TIME += 1
print(CURRENT_TIME)
#configure am and pm
if(convert):
if am == True:
am = False
pm = True
convert = False
else:
am = True
pm = False
convert = False
if am == True:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_TIME], AM_WAV)
else:
# Concatenate three audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
NUMBERS_WAV[CURRENT_TIME], PM_WAV)
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
if c == SET_KEY:
if days_selection == True:
# day is selected
days_selection = False
hours_selection = True
#indicate switch from days to hours
sound.Play(SET_HOUR_WAV)
#listen for user input
c = readchar.readchar()
elif hours_selection = True:
hours_selection = False
else:
sound.Play(EXITING_PROGRAM_WAV)
break
# second time being pressed
if days_selection == False:
sound.Play(EXITING_PROGRAM_WAV)
break
else:
# disable day conditions
days_selection = False
#indicate switch from days to hours
sound.Play(SET_HOUR_WAV)
#listen for user input
c = readchar.readchar()
# User quits.
if c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
# The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
def get_final_time(day,hour_num,minute_num):
final_selection = "final.wav"
AMPM = 0
hour_str = ""
minute_str = ""
zero_str = nav_path + "o_clock_f.wav"
oh_str = num_path + "oh_f.wav"
# Generate the correct string based on the hour of the day
# Also assigns AMPM = 0 if in the morning or else AMPM = 1 for the afternoon and night
if (hour_num == 0):
hour_str = num_path + "12_f.wav"
elif (hour_num == 12):
hour_str = num_path + "12_f.wav"
AMPM = 1
elif (hour_num > 9 and hour_num < 12):
hour_str = num_path + str(hour_num) + "_f.wav"
elif (hour_num < 10 and hour_num >0):
hour_str = num_path + "0" + str(hour_num) + "_f.wav"
elif (hour_num >12 and hour_num < 22):
hour_str = num_path + "0" + str(hour_num - 12) + "_f.wav"
AMPM = 1
elif (hour_num > 21):
hour_str = num_path + str(hour_num-12) + "_f.wav"
AMPM = 1
# If the time is in the AM
if (AMPM == 0):
# If the minutes are 0, we need to put "o' clock" at the end
if (minute_num == 0):
sound.combine_wav_files(final_selection,YOU_SELECTED_WAV,day,hour_str,zero_str,AM_WAV)
# If the number is single digit then, we must put the "oh" in front of the minutes when announcing the selection
elif (minute_num < 10):
minute_str = num_path + "0" + str(minute_num) + "_f.wav"
sound.combine_wav_files(final_selection, YOU_SELECTED_WAV, day, hour_str, oh_str,minute_str, AM_WAV)
# Any other numbers that do not change the way it is said
else:
minute_str = num_path + str(minute_num) + "_f.wav"
sound.combine_wav_files(final_selection, YOU_SELECTED_WAV, day, hour_str, minute_str,AM_WAV)
# If the time is in the PM
elif (AMPM == 1):
# If the minutes are 0, we need to put "o' clock" at the end
if (minute_num == 0):
sound.combine_wav_files(final_selection, YOU_SELECTED_WAV, day, hour_str, zero_str, PM_WAV)
# If the number is single digit then, we must put the "oh" in front of the minutes when announcing the selection
elif (minute_num < 10):
minute_str = num_path + "0" + str(minute_num) + "_f.wav"
sound.combine_wav_files(final_selection, YOU_SELECTED_WAV, day, hour_str, oh_str, minute_str, PM_WAV)
# Any other numbers that do not change the way it is said
else:
minute_str = num_path + str(minute_num) + "_f.wav"
sound.combine_wav_files(final_selection, YOU_SELECTED_WAV, day, hour_str, minute_str, PM_WAV)
# Play the final result of day, hour, minutes, and time of day
sound.Play(final_selection)
def run_submenu():
global CURRENT_SUBMENU_CHOICE
global CURRENT_MENU_CHOICE
global CURRENT_DAY
global CURRENT_HOUR
global CURRENT_MINUTES
global CURRENT_AM_PM
# The following three variables allow the run_submenu() function to operate in a modular fashion.
current_submenu_wav_collection = None
current_entering_menu_wav = None
current_set_to_wav = None
# If the user selected the 'Set Day' sub-menu from the run_menu() function
# Then set up the 'modular' sub-menu variables for 'Set Day' operation.
if CURRENT_MENU_CHOICE == 0:
CURRENT_SUBMENU_CHOICE = CURRENT_DAY
current_submenu_wav_collection = DAYS_WAV
current_entering_menu_wav = ENTERING_DAY_MENU_WAV
current_set_to_wav = DAY_SET_TO_WAV
# If the user selected the 'Set Hour' sub-menu from the run_menu() function
# Then setup the 'modular' sub-menu variables for 'Set Hour' operation.
elif CURRENT_MENU_CHOICE == 1:
CURRENT_SUBMENU_CHOICE = CURRENT_HOUR
current_submenu_wav_collection = HOURS_WAV
current_entering_menu_wav = ENTERING_HOUR_MENU_WAV
current_set_to_wav = HOUR_SET_TO_WAV
# If the user selected the 'Set Minutes' sub-menu from the run_menu() function
# Then setup the 'modular' sub-menu variables for 'Set Minutes' operation.
elif CURRENT_MENU_CHOICE == 2:
CURRENT_SUBMENU_CHOICE = CURRENT_MINUTES
current_submenu_wav_collection = MINUTES_WAV
current_entering_menu_wav = ENTERING_MINUTES_MENU_WAV
current_set_to_wav = MINUTES_SET_TO_WAV
# If the user selected the 'Set AM/PM' sub-menu from the run_menu() function
# Then setup the 'modular' sub-menu variables for 'Set Minutes' operation.
elif CURRENT_MENU_CHOICE == 3:
CURRENT_SUBMENU_CHOICE = CURRENT_AM_PM
current_submenu_wav_collection = AM_AND_PM_WAV
current_entering_menu_wav = ENTERING_AM_PM_MENU_WAV
current_set_to_wav = AM_PM_SET_TO_WAV
# Create and play the Sub-menu transition introduction audio
# "Entering <Selected Sub-menu>. Current selection is <Current Day OR Hour OR Minutes OR AM/PM>. Press the L key for assistance. Press semicolon to return to start."
sound.combine_wav_files(TMP_FILE_WAV, current_entering_menu_wav, CURRENT_SELECTION_IS_WAV,\
current_submenu_wav_collection[CURRENT_SUBMENU_CHOICE], PRESS_L_FOR_HELP_WAV, PRESS_SEMICOLON_TO_RETURN_TO_START_MENU_WAV)
sound.Play(TMP_FILE_WAV)
# Get the first keystroke.
c = readchar.readchar()
while True:
# Respond to the user's input.
if c == FORWARD_KEY:
# Advance the available sub-menu options, looping back around to the start.
CURRENT_SUBMENU_CHOICE += 1
if CURRENT_SUBMENU_CHOICE == len(current_submenu_wav_collection):
CURRENT_SUBMENU_CHOICE = 0
# Play the sub-menu option the user is currently pointing at. (i.e. "Sunday")
sound.Play(current_submenu_wav_collection[CURRENT_SUBMENU_CHOICE])
if c == BACKWARD_KEY:
# Retreat the available sub-menu options, looping back around to the end.
CURRENT_SUBMENU_CHOICE -= 1
if CURRENT_SUBMENU_CHOICE < 0:
CURRENT_SUBMENU_CHOICE = len(
current_submenu_wav_collection) - 1
# Play the sub-menu option the user is currently pointing at. (i.e. "Sunday")
sound.Play(current_submenu_wav_collection[CURRENT_SUBMENU_CHOICE])
if c == SET_KEY:
# MENU CHOICE KEY: 0 -> Set Day, 1 -> Set Hour, 2 -> Set Minutes, 3 -> Set AM/PM
# If current sub-menu is: "Set Day" sub-menu
if CURRENT_MENU_CHOICE == 0:
# Set the current day to the sub-menu option selected by the user
CURRENT_DAY = CURRENT_SUBMENU_CHOICE
# If current sub-menu is: "Set Hour" sub-menu
elif CURRENT_MENU_CHOICE == 1:
# Set the current hour to the sub-menu option selected by the user
CURRENT_HOUR = CURRENT_SUBMENU_CHOICE
# If current sub-menu is: "Set Minutes" sub-menu
elif CURRENT_MENU_CHOICE == 2:
# Set the current minutes to the sub-menu option selected by the user
CURRENT_MINUTES = CURRENT_SUBMENU_CHOICE
# If current sub-menu is: "Set AM/PM" sub-menu
elif CURRENT_MENU_CHOICE == 3:
# Set the current AM/PM to the sub-menu option selected by the user
CURRENT_AM_PM = CURRENT_SUBMENU_CHOICE
# Create and play the Sub-menu exiting transition audio / Start-menu introduction audio:
# "<Current sub-menu> set to <selected day / time>. It is <Current Day and Time>. Press L for help. Press semicolon to return to start."
sound.combine_wav_files(TMP_FILE_WAV, current_set_to_wav, current_submenu_wav_collection[CURRENT_SUBMENU_CHOICE],\
RETURNING_TO_START_MENU_WAV, IT_IS_WAV, DAYS_WAV[CURRENT_DAY],HOURS_WAV[CURRENT_HOUR],MINUTES_WAV[CURRENT_MINUTES],\
AM_AND_PM_WAV[CURRENT_AM_PM],PRESS_L_FOR_HELP_WAV,PRESS_SEMICOLON_TO_QUIT_WAV)
sound.Play(TMP_FILE_WAV)
# Reset the start menu selection pointer to "Set Day"
CURRENT_MENU_CHOICE = 0
#return to the starting menu (give control back torun_menu() function)
return
if c == HELP_KEY:
# Create and play the Sub-menu help audio
# "You are in the <Current sub-menu>. It is <Current Day and Time>. Use the J and K keys... etc."
sound.combine_wav_files(TMP_FILE_WAV, YOU_ARE_IN_THE_MENU_WAV[CURRENT_MENU_CHOICE], IT_IS_WAV,DAYS_WAV[CURRENT_DAY],\
HOURS_WAV[CURRENT_HOUR],MINUTES_WAV[CURRENT_MINUTES],AM_AND_PM_WAV[CURRENT_AM_PM],HELP_WAV)
sound.Play(TMP_FILE_WAV)
if c == QUIT_KEY:
# Create and play the Sub-menu quit audio
# "Returning to the starting menu. It is <Current Day and time>. Press L for help. Press semicolon to quit.
sound.combine_wav_files(TMP_FILE_WAV, RETURNING_TO_START_MENU_WAV, IT_IS_WAV, DAYS_WAV[CURRENT_DAY],HOURS_WAV[CURRENT_HOUR],\
MINUTES_WAV[CURRENT_MINUTES],AM_AND_PM_WAV[CURRENT_AM_PM],PRESS_L_FOR_HELP_WAV,PRESS_SEMICOLON_TO_QUIT_WAV)
sound.Play(TMP_FILE_WAV)
#Reset the start menu selection pointer to "Set Day"
CURRENT_MENU_CHOICE = 0
return
else:
c = readchar.readchar()
def verify_sound_filenames():
print("Verifying sound filenames...")
sound.combine_wav_files(TMP_FILE_WAV,INTRO_WAV,nav_path + "Set_day_of_week_f.wav")
sound.Play(TMP_FILE_WAV)
def set_AMPM():
global CURRENT_TIME
global CURRENT_AMPM
CURRENT_TIME = 0
#Entering new state, play audio to tell user
sound.Play(SET_PERIOD_WAV)
time.sleep(1.5)
#Play current selection of period
sound.combine_wav_files(TMP_FILE_WAV, CURRENT_AMPM_WAV,
AMPM_WAV[CURRENT_TIME])
sound.Play(TMP_FILE_WAV)
time.sleep(2.6)
# Get the first keystroke.
c = readchar.readchar()
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the SELECT_KEY or the QUIT_KEY
while True:
# Respond to the user's input.
if c == FORWARD_KEY:
# Advance the time, looping back around to the start.
CURRENT_TIME += 1
if CURRENT_TIME == 2:
CURRENT_TIME = 0
# Concatenate two audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, AMPM_WAV[CURRENT_TIME])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# Backward key
if c == BACKWARD_KEY:
# Move backward, looping around
CURRENT_TIME -= 1
if CURRENT_TIME == -1:
CURRENT_TIME = 1
# Concatenate two audio files to generate the message.
sound.combine_wav_files(TMP_FILE_WAV, AMPM_WAV[CURRENT_TIME])
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
# Selects current time
if c == SELECT_KEY:
sound.combine_wav_files(TMP_FILE_WAV, YOU_SELECTED_WAV,
AMPM_WAV[CURRENT_TIME])
# Save minute selection
CURRENT_AMPM = CURRENT_TIME
# Play the concatenated file.
sound.Play(TMP_FILE_WAV)
time.sleep(2)
#Selected last input, move on to play result and quit
play_result_and_quit()
break
#User presses help key
if c == HELP_KEY:
# Notify the user that another HELP_KEY will play the help menu
sound.Play(PRESS_AGAIN_FOR_HELP_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed HELP_KEY, play key options
if c == HELP_KEY:
sound.combine_wav_files(TMP_FILE_WAV, QUIT_WAV, HELP_WAV,
DOWN_WAV, UP_WAV, SELECT_WAV)
sound.Play(TMP_FILE_WAV)
# User quits.
if c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
# The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
def run_menu():
global TIME_VAL
CURRENT_VAL = 0 # Current value of time frame being set
CURRENT_STAGE = 0 # Current time frame being set: 1=Day, 2=Hour, 3=Minute
# Provide a minimal indication that the program has started.
print(MINIMAL_HELP_STRING)
# Get the first keystroke.
c = readchar.readchar()
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the QUIT_MENU_KEY.
while True:
# Respond to the user's input.
if c == ADD_KEY:
# Loop over the right list
WAV_LOOP = WEEKDAYS_WAV if CURRENT_STAGE == 0 else NUMBERS_WAV
# Limit possible numbers for hour stage
MAX = 24 if CURRENT_STAGE == 1 else len(WAV_LOOP)
# Advance the time, looping back around to the start.
CURRENT_VAL += 1
if CURRENT_VAL == MAX:
CURRENT_VAL = 0
# Play the concatenated file.
sound.Play(WAV_LOOP[CURRENT_VAL])
if c == SUB_KEY:
# Loop over the right list
WAV_LOOP = WEEKDAYS_WAV if CURRENT_STAGE == 0 else NUMBERS_WAV
# Limit possible numbers for hour stage
MAX = 23 if CURRENT_STAGE == 1 else len(WAV_LOOP) - 1
# Reduce the time, looping forward around to the end.
CURRENT_VAL -= 1
if CURRENT_VAL < 0:
CURRENT_VAL = MAX
# Play the concatenated file.
sound.Play(WAV_LOOP[CURRENT_VAL])
if c == CONTINUE_KEY:
# Set the time frame and move on to the next one.
if CURRENT_STAGE < len(TIME_VAL):
TIME_VAL[CURRENT_STAGE] = CURRENT_VAL
CURRENT_STAGE += 1
CURRENT_VAL = 0 if CURRENT_STAGE == len(TIME_VAL) \
else TIME_VAL[CURRENT_STAGE]
# DEVNOTE: How the hell is one supposed to format a multiline
# ternary operator? It's definitely not this.
introduce_stage(CURRENT_STAGE)
if CURRENT_STAGE >= len(TIME_VAL):
# Program is concluded - build result feedback
RESULT = [ YOU_SELECTED_WAV, WEEKDAYS_WAV[TIME_VAL[0]] ]
if TIME_VAL[1] == 0:
RESULT.append(OH_WAV)
else:
RESULT.append(NUMBERS_WAV[TIME_VAL[1]])
if TIME_VAL[2] == 0:
RESULT.append(O_CLOCK_WAV)
elif 1 <= TIME_VAL[2] and TIME_VAL[2] <= 9:
RESULT.append(OH_WAV)
RESULT.append(NUMBERS_WAV[TIME_VAL[2]])
else:
RESULT.append(NUMBERS_WAV[TIME_VAL[2]])
RESULT.append(EXITING_PROGRAM_WAV)
sound.combine_wav_files(TMP_FILE_WAV, *RESULT)
sound.Play(TMP_FILE_WAV)
time.sleep(5)
# Quit the program
break
if c == UNDO_KEY:
# Revert the time frame
if CURRENT_STAGE > 0:
CURRENT_STAGE -= 1
CURRENT_VAL = TIME_VAL[CURRENT_STAGE]
introduce_stage(CURRENT_STAGE)
# User quits.
if c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
# The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
def Select_Click(self, event):
report_event(event)
event_time = str(event.time)
self.trial_data.append([event_time, event.char])
self.keyCount = self.keyCount + 1
if self.MM_Label["background"] == self.mm_HC:
self.MM_Label["background"] = "white"
self.MM_Label["relief"] = tk.SOLID
if self.Set_Day["background"] == self.cursor_Col:
self.Set_Day["background"] = self.mm_HC
self.Set_Day["relief"] = tk.SUNKEN
self.D_MID["background"] = self.cursor_Col
sound.combine_wav_files(self.TMP_WAV,
MISC_PATH + 'you_selected_f.wav',
MISC_PATH + 'Set_day_of_week_f.wav')
sound.Play(self.TMP_WAV)
elif self.Set_Hour["background"] == self.cursor_Col:
self.Set_Hour["background"] = self.mm_HC
self.Set_Hour["relief"] = tk.SUNKEN
self.H_MID["background"] = self.cursor_Col
sound.combine_wav_files(self.TMP_WAV,
MISC_PATH + 'you_selected_f.wav',
MISC_PATH + 'Set_hour_f.wav')
sound.Play(self.TMP_WAV)
elif self.Set_Min["background"] == self.cursor_Col:
self.Set_Min["background"] = self.mm_HC
self.Set_Min["relief"] = tk.SUNKEN
self.M_MID["background"] = self.cursor_Col
sound.combine_wav_files(self.TMP_WAV,
MISC_PATH + 'you_selected_f.wav',
MISC_PATH + 'Set_minute_f.wav')
sound.Play(self.TMP_WAV)
############# RESET BUTTON #############
elif self.Reset["background"] == self.cursor_Col:
trial_count = 1
trial_time = int(self.trial_data[-1][0]) - int(
self.trial_data[0][0])
while (os.path.exists(data_path + "trial_" + str(trial_count) +
".txt")):
trial_count = trial_count + 1
f = open(data_path + "trial_" + str(trial_count) + ".txt",
"w+")
f.write(str(self.keyCount) + ", " + str(trial_time) + "\n")
for item in self.trial_data:
f.write(str(item[0]) + ", " + str(item[1]) + "\n")
self.day = "Sunday" # unused for now
self.hour = 12
self.minute = 00
self.ampm = 'AM'
self.D_LEFT["text"] = "Saturday"
self.D_MID["text"] = "Sunday"
self.D_RIGHT["text"] = "Monday"
self.hour_ARR = [23, 0, 1]
self.H_LEFT["text"] = self.hour_Str_ampm(self.hour_ARR[0])
self.H_RIGHT["text"] = self.hour_Str_ampm(self.hour_ARR[2])
self.H_MID["text"] = self.hour_Str_ampm(self.hour_ARR[1])
self.min_ARR = [59, 0, 1]
self.M_LEFT["text"] = self.min_Str(self.min_ARR[0])
self.M_RIGHT["text"] = self.min_Str(self.min_ARR[2])
self.M_MID["text"] = self.min_Str(self.min_ARR[1])
self.Day["text"] = "Sunday"
self.Hour["text"] = "12"
self.Min["text"] = "00"
self.AM_PM["text"] = "AM"
self.Reset["background"] = "#ffffff"
self.Set_Day["background"] = self.cursor_Col
self.MM_Label["background"] = self.mm_HC
self.MM_Label["relief"] = tk.SUNKEN
self.keyCount = 0
self.trial_data = []
# sound.Play("extra_wav/reset.wav")
if (trial_count == 1):
self.instructions[
"text"] = "Enter the Time:\nSunday 01:12 AM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count == 2):
self.instructions[
"text"] = "Enter the Time:\nThursday 06:42 AM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count == 3):
self.instructions[
"text"] = "Enter the Time:\nFriday 11:59 PM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count == 4):
self.instructions[
"text"] = "Enter the Time:\nWednesday 04:31 PM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count == 5):
self.instructions[
"text"] = "Enter the Time:\nTuesday 04:44 AM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count == 6):
self.instructions[
"text"] = "Enter the Time:\nSaturday 07:18 PM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count == 7):
self.instructions[
"text"] = "Enter the Time:\nMonday 08:30 AM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count == 8):
self.instructions[
"text"] = "Enter the Time:\nSunday 00:00 PM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count == 9):
self.instructions[
"text"] = "Enter the Time:\nWednesday 04:31 PM\n\nWhen you are done,\n Reset the Time"
self.instructions.grid(row=0, column=0, padx=10, pady=2)
elif (trial_count >= 11):
sound.Play(MISC_PATH + "Exiting_program_f.wav")
try:
self.myParent.after(1500, self.myParent.destroy)
except:
pass
########
########
elif self.Set_Day["background"] == self.mm_HC:
self.Set_Day["relief"] = tk.SOLID
self.Set_Day["background"] = self.cursor_Col
self.MM_Label["background"] = self.mm_HC
self.MM_Label["relief"] = tk.SUNKEN
tmp = ""
self.Day["text"] = self.D_MID["text"]
self.Set_Day["relief"] = tk.SOLID
self.Set_Day["background"] = self.cursor_Col
self.MM_Label["background"] = self.mm_HC
self.MM_Label["relief"] = tk.SUNKEN
self.D_MID["background"] = "white"
self.day = self.Day["text"]
if self.day == "Sunday":
tmp = "sunday_f"
elif self.day == "Monday":
tmp = "monday_f"
elif self.day == "Tuesday":
tmp = "tuesday_f"
elif self.day == "Wednesday":
tmp = "wednesday_f"
elif self.day == "Thursday":
tmp = "thursday_f"
elif self.day == "Friday":
tmp = "friday_f"
elif self.day == "Saturday":
tmp = "saturday_f"
sound.combine_wav_files(self.TMP_WAV,
MISC_PATH + 'you_selected_f.wav',
DAYS_PATH + tmp + '.wav')
sound.Play(self.TMP_WAV)
elif self.Set_Hour["background"] == self.mm_HC:
self.Hour["text"] = self.hour_Str(self.hour_ARR[1])
self.AM_PM["text"] = self.ampm
self.Set_Hour["relief"] = tk.SOLID
self.Set_Hour["background"] = self.cursor_Col
self.MM_Label["background"] = self.mm_HC
self.MM_Label["relief"] = tk.SUNKEN
self.H_MID["background"] = "white"
self.hour = self.hour_ARR[1]
sound.combine_wav_files(
self.TMP_WAV, MISC_PATH + 'you_selected_f.wav',
NUM_PATH + self.hour_Str(self.hour) + '_f.wav',
MISC_PATH + self.ampm + '_f.wav')
sound.Play(self.TMP_WAV)
elif self.Set_Min["background"] == self.mm_HC:
self.Min["text"] = self.min_Str(self.min_ARR[1])
self.Set_Min["relief"] = tk.SOLID
self.Set_Min["background"] = self.cursor_Col
self.MM_Label["background"] = self.mm_HC
self.MM_Label["relief"] = tk.SUNKEN
self.M_MID["background"] = "white"
self.minute = self.min_ARR[1]
sound.combine_wav_files(
self.TMP_WAV, MISC_PATH + 'you_selected_f.wav',
NUM_PATH + self.min_Str(self.minute) + '_f.wav')
sound.Play(self.TMP_WAV)
def run_menu():
global CURRENT_DAY
global CURRENT_HOUR
global CURRENT_MINUTES
global CURRENT_AM_PM
global CURRENT_MENU_CHOICE
# Play the introduction audio
sound.Play(INTRO_WAV)
# Provide a minimal indication that the program has started.
print(MINIMAL_HELP_STRING)
# Get the first keystroke.
c = readchar.readchar()
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the QUIT_MENU_KEY.
while True:
# Respond to the user's input.
if c == FORWARD_KEY:
# Advance the time, looping back around to the start.
CURRENT_MENU_CHOICE += 1
if CURRENT_MENU_CHOICE == len(MENU_CHOICES_WAV):
CURRENT_MENU_CHOICE = 0
sound.Play(MENU_CHOICES_WAV[CURRENT_MENU_CHOICE])
if c == BACKWARD_KEY:
# Retreat the time, looping back around to the end.
CURRENT_MENU_CHOICE -= 1
if CURRENT_MENU_CHOICE < 0:
CURRENT_MENU_CHOICE = len(MENU_CHOICES_WAV) - 1
sound.Play(MENU_CHOICES_WAV[CURRENT_MENU_CHOICE])
if c == SET_KEY:
#Run the sub-menu function. run_submenu() will determine what specific submenu to run based on the value of CURRENT_MENU_CHOICE
run_submenu()
if c == HELP_KEY:
# Create and play the help audio. Starting with the current day and time.
sound.combine_wav_files(TMP_FILE_WAV, IT_IS_WAV,
DAYS_WAV[CURRENT_DAY],
HOURS_WAV[CURRENT_HOUR],
MINUTES_WAV[CURRENT_MINUTES],
AM_AND_PM_WAV[CURRENT_AM_PM], HELP_WAV)
sound.Play(TMP_FILE_WAV)
# User quits.
if c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
return
# The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
def run_menu():
global CURRENT_TIME,LIMIT,days, sound_str,PHASE
# Provide a minimal indication that the program has started.
print("Starting program...\n")
print(MINIMAL_HELP_STRING)
# Get the first keystroke.
c = readchar.readchar()
# Special wav files for instructions
instr_j = "my_sounds/j_to_quit.wav"
instr_k = "my_sounds/k_for_up.wav"
instr_l = "my_sounds/l_for_down.wav"
semi_help = "my_sounds/semi_for_help.wav"
space_to = "my_sounds/space_to.wav"
restart = "my_sounds/restart.wav"
space_conf = "my_sounds/space_to_confirm.wav"
LIMIT = 7
days = ['sunday','monday','tuesday','wednesday','thursday','friday','saturday']
sound_str = "sound_string.wav"
index = ""
# Endless loop responding to the user's last keystroke.
# The loop breaks when the user hits the QUIT_MENU_KEY.
while True:
##### Respond to the user's input.
##### User goes forwards scrolling
if c == FORWARD_KEY:
# Advance the time, looping back around to the start.
CURRENT_TIME += 1
if CURRENT_TIME == LIMIT:
CURRENT_TIME = 0
# Check if in Set Day phase
if PHASE == 0:
sound.Play(day_path + days[CURRENT_TIME] + "_f.wav")
# Check phase to see if Hour Phase
if PHASE == 1:
get_hour(CURRENT_TIME)
#Check if user is in Minute Phase
if PHASE == 2:
get_minutes(CURRENT_TIME)
##### User Goes backwards scrolling
if c == BACKWARD_KEY:
# Decrease the time, looping back around to the start.
CURRENT_TIME -= 1
if CURRENT_TIME < 0:
CURRENT_TIME = LIMIT-1
# Check if in Set Day phase
if PHASE == 0:
sound.Play(day_path + days[CURRENT_TIME] + "_f.wav")
# Check phase to see if Hour phase
if PHASE == 1:
get_hour(CURRENT_TIME)
# Check if User is in Minute Phase
if PHASE == 2:
get_minutes(CURRENT_TIME)
##### When user confirms selection
if c == CONFIRM:
# Check if user is at the end of the program
if next_state() == 1:
time.sleep(4)
# GIve user choice to restart or quit program
sound.combine_wav_files(sound_str,instr_j,space_to,restart)
sound.Play(sound_str)
# Get user's next key input
c = readchar.readchar()
# If the user decides to quit, the program will end
if (c == QUIT_KEY):
sound.Play(EXITING_PROGRAM_WAV)
time.sleep(EXITING_PROGRAM_WAV_DURATION)
break
# If the user decides to restart, the program will restart all its values
# and start the user at setting the day of the week
elif c == CONFIRM:
sound.Play(nav_path + "Set_day_of_week_f.wav")
CURRENT_TIME = 0
LIMIT = 7
PHASE = 0
#### If the User presses for help
if c == HELP:
# Notify the user to press the button again
sound.Play(nav_path + "Press_again_for_help_f.wav")
# Get user's next keystroke
c = readchar.readchar()
# Give the user instructions of the key functions and current phase
# of the program the user is in
if c == HELP:
if PHASE == 0:
help_day = nav_path + "Set_day_of_week_f.wav"
sound.combine_wav_files(sound_str,space_conf,instr_j,instr_k,instr_l,semi_help,help_day)
sound.Play(sound_str)
elif PHASE == 1:
help_hour = nav_path + "Set_hour_f.wav"
sound.combine_wav_files(sound_str,space_conf,instr_j,instr_k,instr_l,semi_help,help_hour)
sound.Play(sound_str)
elif PHASE == 2:
help_day = nav_path + "Set_minutes_f.wav"
sound.combine_wav_files(sound_str,space_conf,instr_j,instr_k,instr_l,semi_help,help_day)
sound.Play(sound_str)
#### User quits.
if c == QUIT_KEY:
# Notify the user that another QUIT_MENU_KEY will quit the program.
sound.Play(PRESS_AGAIN_TO_QUIT_WAV)
# Get the user's next keystroke.
c = readchar.readchar()
# If the user pressed QUIT_MENU_KEY, quit the program.
if c == QUIT_KEY:
sound.Play(EXITING_PROGRAM_WAV)
# A delay is needed so the sound gets played before quitting.
time.sleep(EXITING_PROGRAM_WAV_DURATION)
sound.cleanup()
# Quit the program
break
##### The user presses a key that will have no effect.
else:
# Get the user's next keystroke.
c = readchar.readchar()
