예제 #1
0
class Bartender(MenuDelegate):
    def __init__(self):

        # initialize drink attributes
        self.drink_attributes = {}

        # initialize main menu
        self.mainMenu = None

        # allow button press
        self.running = False

        # initialize the LCD
        self.lcdLayer = LCD.LCDLayer()

        self.btn1Pin = LEFT_BTN_PIN
        self.btn2Pin = RIGHT_BTN_PIN
        self.btn3Pin = UP_BTN_PIN
        self.btn4Pin = DOWN_BTN_PIN

        # configure interrups for buttons
        GPIO.setup(self.btn1Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
        GPIO.setup(self.btn2Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
        GPIO.setup(self.btn3Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
        GPIO.setup(self.btn4Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)

        # load the pump configuration from file
        self.pump_configuration = Bartender.readPumpConfiguration()
        for pump in self.pump_configuration.keys():
            GPIO.setup(
                self.pump_configuration[pump]["pin"],
                GPIO.OUT,
                initial=GPIO.HIGH
                )

        print "Done initializing"

    @staticmethod
    def readPumpConfiguration():
        return json.load(open('pump_config.json'))

    @staticmethod
    def writePumpConfiguration(configuration):
        with open("pump_config.json", "w") as jsonFile:
            json.dump(configuration, jsonFile)

    def startInterrupts(self):
        GPIO.add_event_detect(
            self.btn1Pin,
            GPIO.FALLING,
            callback=self.left_btn,
            bouncetime=LEFT_PIN_BOUNCE
            )
        GPIO.add_event_detect(
            self.btn2Pin,
            GPIO.FALLING,
            callback=self.right_btn,
            bouncetime=RIGHT_PIN_BOUNCE
            )
        GPIO.add_event_detect(
            self.btn3Pin,
            GPIO.FALLING,
            callback=self.up_btn,
            bouncetime=UP_PIN_BOUNCE
            )
        GPIO.add_event_detect(
            self.btn4Pin,
            GPIO.FALLING,
            callback=self.down_btn,
            bouncetime=DOWN_PIN_BOUNCE
            )

    def stopInterrupts(self):
        GPIO.remove_event_detect(self.btn1Pin)
        GPIO.remove_event_detect(self.btn2Pin)
        GPIO.remove_event_detect(self.btn3Pin)
        GPIO.remove_event_detect(self.btn4Pin)

    def buildMenu(self, drink_list, drink_options):
        # create a new main menu
        m = Menu("Main Menu")

        # create a drinks menu
        drinks_menu = Menu("Drinks")

        # add drink options
        drink_opts = []
        for o in drink_options:
            drink_opts.append(
                MenuItem(
                    'drink',
                    o["name"],
                    {
                        "ingredients": {o["value"]: 1},
                        "strong": o["alcohol"],
                        "ice": 0
                    }
                )
            )
        for d in drink_list:
            try:
                drink_opts.append(
                    MenuItem(
                        'drink',
                        d["name"],
                        {
                            "ingredients": d["ingredients"],
                            "strong": d["strong"],
                            "add": d["add"],
                            "ice": d["ice"]
                        }
                    )
                )
            except KeyError:
                drink_opts.append(
                    MenuItem(
                        'drink',
                        d["name"],
                        {
                            "ingredients": d["ingredients"],
                            "strong": d["strong"],
                            "ice": d["ice"]
                        }
                    )
                )
        configuration_menu = Menu("Configure")

        # add pump configuration options
        pump_opts = []
        for p in sorted(self.pump_configuration.keys()):
            config = Menu(self.pump_configuration[p]["name"])
            # add fluid options for each pump
            for opt in drink_options:
                config.addOption(
                    MenuItem(
                        'pump_selection',
                        opt["name"],
                        {"key": p, "value": opt["value"], "name": opt["name"]}
                        )
                    )
            config.setParent(configuration_menu)
            pump_opts.append(config)

        # add pump menus to the configuration menu
        configuration_menu.addOptions(pump_opts)

        # adds an option that cleans all pumps to the configuration menu
        configuration_menu.addOption(MenuItem('clean', 'Clean'))
        configuration_menu.setParent(m)

        drinks_menu.addOptions(drink_opts)
        drinks_menu.setParent(m)
        self.filterDrinks(drinks_menu)

        m.addOption(drinks_menu)
        m.addOption(configuration_menu)

        # create a menu context
        self.menuContext = MenuContext(m, self, self.lcdLayer)

    def setMainMenu(self, menu):
        self.mainMenu = menu

    def filterDrinks(self, menu):
        """
        Removes any drinks that can't be handled by the pump configuration
        """
        for i in menu.options:
            if (i.type == "drink"):
                i.visible = False
                ingredients = i.attributes["ingredients"]
                presentIng = 0
                for ing in ingredients.keys():
                    for p in self.pump_configuration.keys():
                        if (ing == self.pump_configuration[p]["value"]):
                            presentIng += 1
                if (presentIng == len(ingredients.keys())):
                    i.visible = True
            elif (i.type == "menu"):
                self.filterDrinks(i)

    def menuItemClicked(self, menuItem):
        if (menuItem.type == "drink"):
            self.makeDrink(menuItem)
            return True
        elif(menuItem.type == "pump_selection"):
            value = menuItem.attributes["value"]
            self.pump_configuration[
                menuItem.attributes["key"]]["value"] = value
            Bartender.writePumpConfiguration(self.pump_configuration)
            self.menuContext.retreat()
            return True
        elif(menuItem.type == "pour"):
            self.pourDrink(menuItem.attributes)
            return True
        elif(menuItem.type == "clean"):
            self.clean()
            return True
        elif(menuItem.type == "menu_link"):
            if (menuItem.child is not None):
                try:
                    self.drink_attributes.update(menuItem.attributes)
                    print(self.drink_attributes)
                except TypeError:
                    print("menu item has no attributes")
                self.menuContext.currentMenu = menuItem.child
                self.menuContext.showMenu()
                return True
        return False

    def clean(self):
        waitTime = 20
        pumpThreads = []

        # cancel any button presses while the drink is being made
        # self.stopInterrupts()
        self.running = True

        for pump in self.pump_configuration.keys():
            pump_t = threading.Thread(
                target=self.pour,
                args=(self.pump_configuration[pump]["pin"], waitTime)
                )
            pumpThreads.append(pump_t)

        # start the pump threads
        for thread in pumpThreads:
            thread.start()

        # start the progress bar
        self.progressBar(waitTime)

        # wait for threads to finish
        for thread in pumpThreads:
            thread.join()

        # show the main menu
        self.menuContext.showMenu()

        # sleep for a couple seconds to make sure the interrupts
        # don't get triggered
        time.sleep(2)

        # reenable interrupts
        # self.startInterrupts()
        self.running = False

    def pour(self, pin, waitTime):
        GPIO.output(pin, GPIO.LOW)
        print(
            "Starting pour on pin " + str(pin) + " for " + str(waitTime)
            + " seconds")
        time.sleep(waitTime)
        GPIO.output(pin, GPIO.HIGH)
        print("Stopping pour on pin " + str(pin))

    def progressBar(self, waitTime):
        self.lcdLayer.lcd_blank()
        self.lcdLayer.lcd_string("Pouring", LCD.LCD_LINE_1, LCD.CENTERED)
        self.lcdLayer.lcd_byte(
            LCD.LCD_LINE_3
            | LCD.LCD_SET_DDRAM, LCD.LCD_RS_CMD)
        block = 0xff
        for i in range(20):
            self.lcdLayer.lcd_byte(block, LCD.LCD_RS_CHR)
            time.sleep(waitTime / 20)
        return True

    def makeDrink(self, drink):
        # Check for strength
        if (drink.attributes["strong"] == 1):
            strengthCheck = Menu("This drink is strong")
            strengthCheck.addOption(MenuLink(
                "Continue", strengthCheck, None, {"strength": "normal"}))
            strengthCheck.setParent(self.menuContext.currentMenu)
            self.menuContext.setMenu(strengthCheck)
        else:
            # Select strength
            strengthSelect = Menu("Select strength")
            strengthSelect.addOption(MenuLink(
                "Weak", strengthSelect, None, {"strength": "weak"}))
            strengthSelect.addOption(MenuLink(
                "Normal", strengthSelect, None, {"strength": "normal"}))
            strengthSelect.addOption(MenuLink(
                "Strong", strengthSelect, None, {"strength": "strong"}))
            strengthSelect.setParent(self.menuContext.currentMenu)
            self.menuContext.setMenu(strengthSelect)
        # Select size
        # create a size menu and point it back to strengthCheck or
        # strengthSelect
        sizeSelect = Menu("Select size")
        sizeSelect.setParent(self.menuContext.currentMenu)
        for links in self.menuContext.currentMenu.options:
            if links.type == "menu_link":
                links.setChild(sizeSelect)

        # add size options menus to strengthCheck and strengthSelect
        sizeSelect.addOption(MenuLink(
            "Shot", sizeSelect, None, {"size": "shot"}))
        sizeSelect.addOption(MenuLink(
            "4 oz", sizeSelect, None, {"size": "4 oz"}))
        sizeSelect.addOption(MenuLink(
            "6 oz", sizeSelect, None, {"size": "6 oz"}))
        sizeSelect.addOption(MenuLink(
            "8 oz", sizeSelect, None, {"size": "8 oz"}))
        sizeSelect.addOption(MenuLink(
            "10 oz", sizeSelect, None, {"size": "10 oz"}))
        sizeSelect.addOption(MenuLink(
            "12 oz", sizeSelect, None, {"size": "12 oz"}))

        # pour menu
        pour = Menu("Ready to pour?")
        pour.addOption(MenuItem("pour", "Continue", drink.attributes))

        # add ice
        if (drink.attributes["ice"] == 1):
            addIce = Menu("Add Ice")
            addIce.setParent(sizeSelect)
            pour.setParent(addIce)
            addIce.addOption(MenuLink(
                "Continue", addIce, pour))
            for option in sizeSelect.options:
                if option.type == "menu_link":
                    option.setChild(addIce)
        else:
            pour.setParent(sizeSelect)
            for option in sizeSelect.options:
                if option.type == "menu_link":
                    option.setChild(pour)

        # finally show the menu structure
        self.menuContext.showMenu()

    def pourDrink(self, drinkAttributes):
        self.running = True
        ingredients = drinkAttributes["ingredients"].copy()
        print("Ingredients: " + str(ingredients.keys()))
        size = self.drink_attributes["size"].split()[0]
        if size == "shot":
            size = 1.25
        else:
            size = float(size)
        print("Size = " + str(size) + " oz")
        strength = self.drink_attributes["strength"]
        print("Strength: " + str(strength))
        alcModifier = 1.0

        if (strength == "strong"):
            alcModifier = 1.3
        elif (strength == "weak"):
            alcModifier = 0.7

        # strength calculations
        totalIngredients = 0.0
        for ing in ingredients:
            totalIngredients += ingredients[ing]
            for opts in drink_options:
                if (ing == opts["value"]
                        and opts["alcohol"] == 1):
                    ingredients.update(
                        {ing: ingredients[ing] * 1.00 * alcModifier})

        print("Total parts: " + str(totalIngredients))

        # size calculations
        for ing in ingredients:
            ingredients.update(
                {ing: ingredients[ing] * size / totalIngredients})
            print(str(ingredients[ing]) + " oz of " + str(ing))

        maxTime = 0.00
        pumpThreads = []

        for ing in ingredients.keys():
            print("Looking for pump for ingredient: " + str(ing))
            found = False
            for pump in self.pump_configuration.keys():
                print("Checking pump " + str(pump))
                print(
                    "This pump is for: "
                    + str(self.pump_configuration[pump]["value"]))
                if ing == self.pump_configuration[pump]["value"]:
                    waitTime = (ingredients[ing] * 1.00) / FLOW_RATE
                    # oz/(oz/sec)=sec
                    if (waitTime > maxTime):
                        maxTime = waitTime
                    pump_t = threading.Thread(
                        target=self.pour,
                        args=(self.pump_configuration[pump]["pin"], waitTime)
                        )
                    print(
                        "Found pump for " + str(ing)
                        + ". Setting up pour for " + str(waitTime) + " sec")
                    pumpThreads.append(pump_t)
                    found = True
            if (not found):
                print("Could not find pump for ingredient: " + str(ing))

        print("Total pour time: " + str(maxTime))

        # start the pump threads
        for thread in pumpThreads:
            thread.start()

        # start the progress bar
        self.progressBar(maxTime)

        # wait for threads to finish
        for thread in pumpThreads:
            thread.join()

        # sleep for a couple seconds to make sure the interrupts
        # don't get triggered
        time.sleep(2)

        # reenable interrupts
        # self.startInterrupts()
        self.running = False

        # check for additions
        try:
            addMenu = Menu("Just add " + self.drink_attributes["add"])
            addMenu.addOption(MenuLink("Done", None, self.mainMenu))
            addMenu.setParent(self.mainMenu)
            self.menuContext.setMenu(addMenu)
        except KeyError:
            self.menuContext.setMenu(self.mainMenu)

        self.drink_attributes = {}
        self.menuContext.showMenu()

    def down_btn(self, ctx):
        if not self.running:
            self.menuContext.scroll_down()

    def up_btn(self, ctx):
        if not self.running:
            self.menuContext.scroll_up()

    def left_btn(self, ctx):
        if not self.running:
            self.menuContext.retreat()

    def right_btn(self, ctx):
        if not self.running:
            self.menuContext.select()

    def run(self):
        self.menuContext.showMenu()
        self.startInterrupts()

        # main loop
        try:
            while True:
                time.sleep(0.1)

        except KeyboardInterrupt:
            self.lcdLayer.lcd_cleanup()       # clean up GPIO on CTRL+C exit
        self.lcdLayer.lcd_cleanup()           # clean up GPIO on normal exit

        traceback.print_exc()
예제 #2
0
class Bartender(MenuDelegate):
    def __init__(self):
        self.running = False

        # set the oled screen height
        self.screen_width = SCREEN_WIDTH
        self.screen_height = SCREEN_HEIGHT

        self.make_drink = MAKE_DRINK

        self.btn1Pin = LEFT_BTN_PIN
        self.btn2Pin = RIGHT_BTN_PIN

        self.clk = CLK_PIN
        self.dt = DT_PIN

        # configure interrupts for buttons
        #GPIO.setup(self.btn1Pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
        GPIO.setup(self.btn2Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)

        # configure interrupts for encoder
        GPIO.setup(self.clk, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
        GPIO.setup(self.dt, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

        #Pi config
        RST = 21
        DC = 20
        SPI_PORT = 0
        SPI_DEVICE = 0

        # configure screen
        self.disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
        self.disp.begin()
        self.disp.clear()
        self.disp.display()

        #draw
        self.image = Image.new('1', (SCREEN_WIDTH, SCREEN_HEIGHT))
        self.draw = ImageDraw.Draw(self.image)
        self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
                            outline=0,
                            fill=0)
        self.font = ImageFont.load_default()

        # Very important... This lets py-gaugette 'know' what pins to use in order to reset the display
        # Change rows & cols values depending on your display dimensions.

        # load the pump configuration from file
        self.pump_configuration = Bartender.readJson(
            '/home/pi/Documents/PiDrink/static/json/pump_config.json')
        for pump in self.pump_configuration.keys():
            GPIO.setup(self.pump_configuration[pump]["pin"],
                       GPIO.OUT,
                       initial=GPIO.HIGH)

        # load the current drink list
        self.drink_list = Bartender.readJson(
            '/home/pi/Documents/PiDrink/static/json/drink_list.json')
        self.drink_list = self.drink_list["drink_list"]

        # load the current drink options
        self.drink_options = Bartender.readJson(
            '/home/pi/Documents/PiDrink/static/json/drink_options.json')
        self.drink_options = self.drink_options["drink_options"]

        # setup pixels:
        self.numpixels = NUMBER_NEOPIXELS  # Number of LEDs in strip

        # Here's how to control the strip from any two GPIO pins:
        datapin = NEOPIXEL_DATA_PIN
        clockpin = NEOPIXEL_CLOCK_PIN
        self.strip = Adafruit_DotStar(self.numpixels, datapin, clockpin)
        self.strip.begin()  # Initialize pins for output
        self.strip.setBrightness(
            NEOPIXEL_BRIGHTNESS)  # Limit brightness to ~1/4 duty cycle

        # turn everything off
        for i in range(0, self.numpixels):
            self.strip.setPixelColor(i, 0)
        self.strip.show()

        print('Done initializing')

    # def check_email(self):
    # 	status, email_ids = self.imap_server.search(None, '(UNSEEN)')
    # 	if email_ids == ['']:
    # 		mail_list = []
    # 	else:
    # 		mail_list = self.get_subjects(email_ids) #FYI when calling the get_subjects function, the email is marked as 'read'
    # 	self.imap_server.close()
    # 	return mail_list

    # def get_subjects(self, email_ids):
    # 	subjects_list = []
    # 	for e_id in email_ids[0].split():
    # 		resp, data = self.imap_server.fetch(e_id, '(RFC822)')
    # 		perf = HeaderParser().parsestr(data[0][1])
    # 		subjects_list.append(perf['Subject'])

    # 	return subjects_list

    def voice_command(self, mail_list):
        for mail in mail_list:
            found = False
            while (found == False):
                currmen = self.menuContext.currentMenu.getSelection()
                if (currmen.name == mail):
                    self.makeDrink(currmen.name,
                                   currmen.attributes["ingredients"])
                    self.make_drink = False
                    found = True
                else:
                    self.menuContext.currentMenu.nextSelection()
            found = False

    @staticmethod
    def readJson(file):
        return json.load(open(file))

    @staticmethod
    def writePumpConfiguration(configuration):
        with open("/home/pi/Documents/PiDrink/static/json/pump_config.json",
                  "w") as jsonFile:
            json.dump(configuration, jsonFile)

    def startInterrupts(self):
        #GPIO.add_event_detect(self.btn1Pin, GPIO.FALLING, callback=self.left_btn, bouncetime=LEFT_PIN_BOUNCE)
        GPIO.add_event_detect(self.btn2Pin,
                              GPIO.FALLING,
                              callback=self.right_btn,
                              bouncetime=RIGHT_PIN_BOUNCE)
        GPIO.add_event_detect(self.clk,
                              GPIO.BOTH,
                              callback=self.rotary_on_change,
                              bouncetime=1000)

    def stopInterrupts(self):
        #GPIO.remove_event_detect(self.btn1Pin)
        GPIO.remove_event_detect(self.btn2Pin)
        GPIO.remove_event_detect(self.clk)

    def buildMenu(self):
        # create a new main menu
        m = Menu("Main Menu")

        # add drink options
        drink_opts = []
        for d in self.drink_list:
            drink_opts.append(
                MenuItem('drink', d["name"],
                         {"ingredients": d["ingredients"]}))

        configuration_menu = Menu("Configure")

        # add pump configuration options
        pump_opts = []
        for p in sorted(self.pump_configuration.keys()):
            config = Menu(self.pump_configuration[p]["name"])
            # add fluid options for each pump
            for opt in self.drink_options:
                # star the selected option
                selected = "*" if opt["value"] == self.pump_configuration[p][
                    "value"] else ""
                config.addOption(
                    MenuItem('pump_selection', opt["name"], {
                        "key": p,
                        "value": opt["value"],
                        "name": opt["name"]
                    }))

            # add a back button so the user can return without modifying
            config.addOption(Back("Back"))
            config.setParent(configuration_menu)
            pump_opts.append(config)

        # add pump menus to the configuration menu
        configuration_menu.addOptions(pump_opts)
        # add a back button to the configuration menu
        configuration_menu.addOption(Back("Back"))
        # adds an option that cleans all pumps to the configuration menu
        configuration_menu.addOption(MenuItem('clean', 'Clean'))
        configuration_menu.setParent(m)

        m.addOptions(drink_opts)
        m.addOption(configuration_menu)
        # create a menu context
        self.menuContext = MenuContext(m, self)

    def filterDrinks(self, menu):
        """
		Removes any drinks that can't be handled by the pump configuration
		"""
        for i in menu.options:
            if (i.type == "drink"):
                i.visible = False
                ingredients = i.attributes["ingredients"]
                presentIng = 0
                for ing in ingredients.keys():
                    for p in self.pump_configuration.keys():
                        if (ing == self.pump_configuration[p]["value"]):
                            presentIng += 1
                if (presentIng == len(ingredients.keys())):
                    i.visible = True
            elif (i.type == "menu"):
                self.filterDrinks(i)

    def selectConfigurations(self, menu):
        """
		Adds a selection star to the pump configuration option
		"""
        for i in menu.options:
            if (i.type == "pump_selection"):
                key = i.attributes["key"]
                if (self.pump_configuration[key]["value"] ==
                        i.attributes["value"]):
                    i.name = "%s %s" % (i.attributes["name"], "*")
                else:
                    i.name = i.attributes["name"]
            elif (i.type == "menu"):
                self.selectConfigurations(i)

    def prepareForRender(self, menu):
        self.filterDrinks(menu)
        self.selectConfigurations(menu)
        return True

    def menuItemClicked(self, menuItem):
        if (menuItem.type == "drink"):
            if self.make_drink:
                self.makeDrink(menuItem.name,
                               menuItem.attributes["ingredients"])
                self.make_drink = False
            return True
        elif (menuItem.type == "pump_selection"):
            self.pump_configuration[menuItem.attributes["key"]][
                "value"] = menuItem.attributes["value"]
            Bartender.writePumpConfiguration(self.pump_configuration)
            return True
        elif (menuItem.type == "clean"):
            if self.make_drink:
                self.clean()
                self.make_drink = False
            return True
        return False

    def changeConfiguration(self, pumps):
        # Change configuration of every pump
        for i in range(1, 7):
            self.pump_configuration["pump_" + str(i)]["value"] = pumps[i - 1]

        Bartender.writePumpConfiguration(self.pump_configuration)

    def clean(self):
        waitTime = 30
        pumpProcesses = []

        # cancel any button presses while the drink is being made
        # self.stopInterrupts()
        self.running = True

        for pump in self.pump_configuration.keys():
            pump_p = threading.Thread(target=self.pour,
                                      args=(
                                          self.pump_configuration[pump]["pin"],
                                          waitTime,
                                      ))
            pumpProcesses.append(pump_p)

        disp_process = threading.Thread(target=self.progressBar,
                                        args=(waitTime, ))
        pumpProcesses.append(disp_process)

        # start the pump threads
        for process in pumpProcesses:
            process.start()

        # wait for threads to finish
        for process in pumpProcesses:
            process.join()

        # sleep for a couple seconds to make sure the interrupts don't get triggered
        time.sleep(2)

        # reenable interrupts
        # self.startInterrupts()
        self.running = False
        self.make_drink = True

        self.menuContext.showMenu()

    def displayMenuItem(self, menuItem):
        #Clear display
        self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
                            outline=0,
                            fill=0)
        self.draw.text((20, 10), menuItem.name, font=self.font, fill=255)
        self.disp.image(self.image)
        self.disp.display()

    def cycleLights(self):
        t = threading.currentThread()
        head = 0  # Index of first 'on' pixel
        tail = -10  # Index of last 'off' pixel
        color = 0xFF0000  # 'On' color (starts red)

        while getattr(t, "do_run", True):
            self.strip.setPixelColor(head, color)  # Turn on 'head' pixel
            self.strip.setPixelColor(tail, 0)  # Turn off 'tail'
            self.strip.show()  # Refresh strip
            time.sleep(1.0 / 50)  # Pause 20 milliseconds (~50 fps)

            head += 1  # Advance head position
            if (head >= self.numpixels):  # Off end of strip?
                head = 0  # Reset to start
                color >>= 8  # Red->green->blue->black
                if (color == 0): color = 0xFF0000  # If black, reset to red

            tail += 1  # Advance tail position
            if (tail >= self.numpixels): tail = 0  # Off end? Reset

    def lightsEndingSequence(self):
        # make lights green
        for i in range(0, self.numpixels):
            self.strip.setPixelColor(i, 0xFF0000)
        self.strip.show()

        time.sleep(5)

        # turn lights off
        for i in range(0, self.numpixels):
            self.strip.setPixelColor(i, 0)
        self.strip.show()

    def pour(self, pin, waitTime):
        GPIO.output(pin, GPIO.LOW)
        time.sleep(waitTime)
        GPIO.output(pin, GPIO.HIGH)

    def progressBar(self, waitTime):
        interval = waitTime / 116.3

        for x in range(1, 101):
            # Clear display
            self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
                                outline=0,
                                fill=0)
            #self.draw.text((55,20), str(x) + '%', font = self.font, fill=255)
            self.updateProgressBar(x, y=10)
            self.disp.image(self.image)
            self.disp.display()
            time.sleep(interval)
        # 	# self.disp.clear()
        # 	# self.disp.display()

        # self.image = Image.open('happycat_oled_32.ppm').convert('1')

        # self.disp.image(self.image)
        # self.disp.display()

    def makeDrink(self, drink, ingredients):
        if self.running:
            return

        # cancel any button presses while the drink is being made
        # self.stopInterrupts()
        print('Making a ' + drink)
        self.running = True

        # launch a thread to control lighting
        lightsThread = threading.Thread(target=self.cycleLights)
        lightsThread.start()

        # Make a list for each potential time

        maxTime = 0
        pumpProcesses = []
        for ing in ingredients.keys():
            for pump in self.pump_configuration.keys():
                if ing == self.pump_configuration[pump]["value"]:
                    waitTime = ingredients[ing] * FLOW_RATE
                    if (waitTime > maxTime):
                        maxTime = waitTime
                    pump_p = threading.Thread(
                        target=self.pour,
                        args=(self.pump_configuration[pump]["pin"], waitTime))
                    pumpProcesses.append(pump_p)

        disp_process = threading.Thread(target=self.progressBar,
                                        args=(maxTime, ))
        pumpProcesses.append(disp_process)

        # start the pump threads
        for process in pumpProcesses:
            process.start()

        # wait for threads to finish
        for process in pumpProcesses:
            process.join()

        # stop the light thread
        lightsThread.do_run = False
        lightsThread.join()

        # show the ending sequence lights
        self.lightsEndingSequence()

        # reenable interrupts
        # sleep for a couple seconds to make sure the interrupts don't get triggered
        time.sleep(2)
        # self.startInterrupts()
        self.running = False
        print('Finished making ' + drink)
        self.make_drink = True

        # show the main menu
        self.menuContext.showMenu()

    def left_btn(self, ctx):
        if not self.running:
            self.menuContext.advance()

    def right_btn(self, ctx):
        if not self.running:
            self.menuContext.select()

    def rotary_on_change(self, ctx):
        if not self.running:
            if GPIO.input(self.dt):
                self.menuContext.retreat()
            else:
                self.menuContext.advance()

    def get_ingredients_time(self, drink):
        # Get the ingredients for the specified drink
        found = False
        while (found == False):
            currmen = self.menuContext.currentMenu.getSelection()
            if (currmen.name == drink):
                ingredients = currmen.attributes["ingredients"]
                self.make_drink = False
                found = True
            else:
                self.menuContext.currentMenu.nextSelection()

        # Get the drink making time
        maxTime = 0
        for ing in ingredients.keys():
            for pump in self.pump_configuration.keys():
                if ing == self.pump_configuration[pump]["value"]:
                    waitTime = ingredients[ing] * FLOW_RATE
                    if (waitTime > maxTime):
                        maxTime = waitTime

        # Return making time and ingredients for drink
        return ingredients, maxTime

    def updateProgressBar(self, percent, x=15, y=10):

        height = 10
        width = self.screen_width - 2 * x

        for w in range(0, width):
            self.draw.point((w + x, y), fill=255)
            self.draw.point((w + x, y + height), fill=255)
        for h in range(0, height):
            self.draw.point((x, h + y), fill=255)
            self.draw.point((self.screen_width - x, h + y), fill=255)
            for p in range(0, percent):
                p_loc = int(p / 100.0 * width)
                self.draw.point((x + p_loc, h + y), fill=255)
                self.draw.text((55, 20),
                               str(percent) + '%',
                               font=self.font,
                               fill=255)
                #self.disp.image(self.image)
            #self.disp.display()

    def endprogram(self):
        global stopprogram

        stopprogram = True

        # Goodbye message
        self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
                            outline=0,
                            fill=0)
        self.draw.text((25, 10), "Goodbye...", font=self.font, fill=255)
        self.disp.image(self.image)
        self.disp.display()
        time.sleep(3)

        self.draw.rectangle((0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
                            outline=0,
                            fill=0)
        self.draw.text((15, 10), "Have a great day!", font=self.font, fill=255)
        self.disp.image(self.image)
        self.disp.display()

        time.sleep(3)
        self.disp.clear()
        self.disp.display()

    def run(self):
        self.startInterrupts()
        # main loop
        try:
            while True:
                if stopprogram:
                    return
                # self.imap_server = imaplib.IMAP4_SSL("imap.gmail.com",993)
                # self.imap_server.login(USERNAME, PASSWORD)
                # self.imap_server.select('INBOX')
                # mail_list = self.check_email()
                # if mail_list and not self.running:
                # 	self.voice_command(mail_list)
                time.sleep(0.1)

        except KeyboardInterrupt:
            GPIO.cleanup()  # clean up GPIO on CTRL+C exit
            sys.exit(0)

        GPIO.cleanup()  # clean up GPIO on normal exit

        traceback.print_exc()