Alexa's Little Helper

#!/usr/bin/env python3

"""
ALEXA'S LITTLE HELPER (Skill invocation "your little helper")

Creator
-------
Keith Rosenheck 2019

Credits
-------
I learnt from a lot of good work by a lot of good people to help me get this project done. This included copying sample code and modifying it to suit this project.
My main sources of information and examples were:

- The tutorial for the Lego MindStorms Voice Challenge:
    - https://www.hackster.io/alexagadgets/lego-mindstorms-voice-challenge-setup-17300f

- Amazon's Gadget Toolkit and Rasberry PI Examples:
    - https://developer.amazon.com/en-US/docs/alexa/alexa-gadgets-toolkit/features.html
    - https://github.com/alexa/Alexa-Gadgets-Raspberry-Pi-Samples

- The EV3DEV project:
    - https://www.ev3dev.org/docs/getting-started/

- The EV3 Python site:
    - https://sites.google.com/site/ev3devpython/learn_ev3_python

- The NXT-PYTHON project:
    - https://github.com/eelviny/nxt-python

- Other resources helped out too:
    - https://github.com/ev3dev/ev3dev-lang-python
    - https://cheatsheet.c4f.wtf/python-ev3dev
    - https://medium.com/@yzhong.cs/serialize-and-deserialize-complex-json-in-python-205ecc636caa
    - https://medium.com/python-pandemonium/json-the-python-way-91aac95d4041
    - The LEGO MINDSTORMS EV3 Idea Book: 181 Simple Machines and Clever Contraptions - By Yoshihito Isogawa


EV3 PORTS
---------
A: NXT Notification Flag Motor
B: Left EV3 Large Motor - Tank
C: Right EV3 Large Motor - Tank
D: Medium EV3 Tilt Motor
1: Front Left NXT Ultrasonic Sensor
2: Front Right NXT Ultrasonic Sensor
3: Rear Feelers EV3 Color Sensor
4: Front Object Detection Infrared Sensor

NXT PORTS
---------
A:
B:
C: NXT Spinner Motor
1: Tilt State NXT Touch Button
2: Notification Flag State NXT Touch Button
3:
4:
"""
import sys
import os
import time
import logging
import threading
import subprocess
import dateutil.parser
from enum import Enum
from datetime import datetime

from agt import AlexaGadget

from ev3dev2.led import Leds
from ev3dev2.sound import Sound
from ev3dev2.motor import (
    OUTPUT_A,
    OUTPUT_B,
    OUTPUT_C,
    OUTPUT_D,
    MoveTank,
    SpeedPercent,
    MediumMotor,
    LargeMotor,
)
from ev3dev2.sensor.lego import UltrasonicSensor
from ev3dev2.sensor.lego import ColorSensor
from ev3dev2.sensor.lego import InfraredSensor
from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_3, INPUT_4
from ev3dev2.button import Button
from ev3dev2.power import PowerSupply

import nxt as nxt_brick
from nxt.locator import find_one_brick
from nxt.motor import Motor, PORT_A, PORT_B, PORT_C
from nxt.sensor import Light, Touch, Ultrasonic
from nxt.sensor import PORT_1, PORT_2, PORT_3, PORT_4

from typing import List
import json

import os.path
from os import path

# declare constants
SPEED = 20
TILT_DEGREES = 1135
SURFACE_DISTANCE_MIN = 7
PROXIMITY_DISTANCE_MIN = 15
REFELECTED_LIGHT_MIN = 18
LOCATION_HOME = "home"
LOCATION_UNKNOWN = "unknown"

# Set the logging level to INFO to see messages from AlexaGadget
logging.basicConfig(level=logging.INFO)


class Direction(Enum):
    """
    The list of directional commands and their variations.
    These variations correspond to the skill slot values.
    """

    FORWARD = ["forward", "forwards", "go forward"]
    BACKWARD = ["back", "backward", "backwards", "go backward"]
    LEFT = ["left", "go left"]
    RIGHT = ["right", "go right"]
    STOP = ["stop", "brake", "halt"]


class Command(Enum):
    """
    The list of preset commands and their invocation variation.
    These variations correspond to the skill slot values.
    """

    TILT = ["tilt"]
    PRINT_DATA = ["print"]
    BATTERY = ["battery", "battery level"]
    POWER_DOWN = ["power_down"]
    LOCATION_SET_CURRENT = ["set", "set current", "set position", "set location", "set current location", "set current position"]
    LOCATION_SAVE = ["save", "save location", "save position"]
    LOCATION_GOTO = ["go to", "goto"]
    LOCATION_REMOVE = ["remove", "remove location", "remove position", "delete", "delete location", "delete position"]


class Move(object):
    """
    Capture move data for later replay if required
    """
    def __init__(self, direction: str, distance: int, speed: int):
        self.direction = direction
        self.distance = distance
        self.speed = speed

    @classmethod
    def from_json(cls, data):
        return cls(**data)


class Location(object):
    """
    Capture a location as a collection of moves
    """
    def __init__(self, moves: List[Move]):
        self.moves = moves

    @classmethod
    def from_json(cls, data):
        moves = list(map(Move.from_json, data["moves"]))
        return cls(moves)


class MindstormsGadget(AlexaGadget):
    """
    A Mindstorms gadget that can perform bi-directional interaction with an Alexa skill.
    """

    def __init__(self):
        """
        Performs Alexa Gadget initialization routines and ev3dev resource allocation.
        """
        super().__init__()

        # find the NXT brick
        self.outputToConsole("About to look for NXT brick")
        self.nxtBrick = nxt_brick.locator.find_one_brick()
        self.outputToConsole("Found NXT brick")

        # setup the tank drive and use one of its motors for data capture
        self.tankDrive = MoveTank(OUTPUT_B, OUTPUT_C)
        self.largeMotorB = LargeMotor(OUTPUT_B)

        # setup the tilt motor
        self.mediumTiltMotor = MediumMotor(OUTPUT_D)
        self.mediumTiltMotor.reset()

        # setup the timer and notification motors
        self.nxtNotificationMotor = LargeMotor(OUTPUT_A)
        self.nxtTimerMotor = Motor(self.nxtBrick, PORT_C)

        # setup sensors
        self.frontLeftNxtUltrasonic = UltrasonicSensor(INPUT_1)
        self.frontRightNxtUltrasonic = UltrasonicSensor(INPUT_2)
        self.rearEv3Colour = ColorSensor(INPUT_3)
        self.frontEv3InfraRed = InfraredSensor(INPUT_4)
        self.nxtTiltButton = Touch(self.nxtBrick, PORT_1)
        self.nxtFlagButton = Touch(self.nxtBrick, PORT_2)

        # setup extra info and feedback objects
        self.powerSupply = PowerSupply()
        self.sound = Sound()
        self.leds = Leds()

        # init sensor reading variables
        self.frontLeftNxtUltrasonicDistance = 0
        self.frontRightNxtUltrasonicDistance = 0
        self.frontEv3InfraRedProximity = 0
        self.rearEv3ColourReflectedLight = 0
        self.nxtTiltButtonPressed = False
        self.nxtFlagButtonPressed = False

        # init other variables
        self.forwardStop = True
        self.backwardStop = True
        self.powerDown = False
        self.currentLocationName = LOCATION_HOME
        self.movesList = []
        self.recordMoves = True
        self.movedSomewhere = False
        self.setTheTimeRecently = False

        # init timer response variables
        self.timer_thread = None
        self.timer_token = None
        self.timer_end_time = None

        # fire up the detection thread looking for edges and objects to avoid
        threading.Thread(target=self.detection, daemon=True).start()

    def on_connected(self, device_addr):
        """
        Gadget connected to the paired Echo device.
        """
        print("{} connected to Echo device".format(self.friendly_name))

        self.sound.play_song((("C4", "e"), ("D4", "e"), ("E5", "q")))

    def on_disconnected(self, device_addr):
        """
        Gadget disconnected from the paired Echo device.
        """
        print("{} disconnected from Echo device".format(self.friendly_name))

    def on_alexa_gadget_statelistener_stateupdate(self, directive):
        """
        Handles the Alexa.Gadget.StateListener state updates
        """
        # do we have a state update to do something with
        if len(directive.payload.states) > 0:
            statusUpdate = directive.payload.states[0]

            if statusUpdate.name == "timeinfo":
                # getting two time status updates at the start and as they're both he same time, the second setting of it actually makes the time a second or two out
                if not self.setTheTimeRecently:
                    os.system("sudo date -s '{}'".format(statusUpdate.value))
                    self.outputToConsole("Set the time to '{0}' and the current time is '{1}'".format(statusUpdate.value, datetime.now()))
                    self.setTheTimeRecently = True
                else:
                    self.outputToConsole("Ignoring timeinfo update as it hasn't been long enough since we last set the time")

    def on_alerts_setalert(self, directive):
        """
        Handles Alerts.SetAlert directive sent from Echo Device
        """
        # check that this is a timer. if it is something else (alarm, reminder), just ignore
        if directive.payload.type != 'TIMER':
            return

        # parse the scheduledTime in the directive. if is already expired, ignore
        t = dateutil.parser.parse(directive.payload.scheduledTime).timestamp()
        if t <= 0:
            self.outputToConsole("Received SetAlert directive but scheduledTime has already passed. Ignoring")
            return

        # check if this is an update to an already running timer (e.g. users asks alexa to add 30s), if it is, just adjust the end time
        if self.timer_token == directive.payload.token:
            self.outputToConsole("Received SetAlert directive to update to currently running timer. Adjusting")
            self.timer_end_time = t
            return

        # check if another timer is already running. if it is, just ignore this one
        if self.timer_thread is not None and self.timer_thread.isAlive():
            self.outputToConsole("Received SetAlert directive but another timer is already running. Ignoring")
            return

        # start a thread to countdown till the timer goes off
        self.outputToConsole("Received SetAlert directive ({0}). Starting a timer. {1}".format(directive.payload.scheduledTime, str(int(t - time.time())) + " seconds left.."))
        self.timer_end_time = t
        self.timer_token = directive.payload.token

        # run timer in it's own thread to prevent blocking future directives during count down
        self.timer_thread = threading.Thread(target=self.timer_countdown)
        self.timer_thread.start()

    def on_alerts_deletealert(self, directive):
        """
        Handles Alerts.DeleteAlert directive sent from Echo Device
        """
        # check if this is for the currently running timer. if not, just ignore
        if self.timer_token != directive.payload.token:
            self.outputToConsole("Received DeleteAlert directive but not for the currently active timer. Ignoring")
            return

        # delete the timer, and stop the currently running timer thread
        self.outputToConsole("Received DeleteAlert directive. Cancelling the timer")
        self.timer_token = None

        # stop the spinner
        self.runTimerSpinner(0)

    def timer_countdown(self):
        """
        Handles making the stand run a spinner when an Alexa timer goes off
        """
        time_remaining = max(0, self.timer_end_time - time.time())
        while self.timer_token and time_remaining > 1.5:
            # update the time remaining
            time_remaining = max(0, self.timer_end_time - time.time())

            time.sleep(0.2)

        # if we still have a valid token then the timer expired so lets dance
        if self.timer_token:
            self.runTimerSpinner(90)

    def on_notifications_setindicator(self, directive):
        """
        Handles raising the flag if a notifaction is received
        """
        self.outputToConsole("Received notification")
        self.setNotificationFlag(True)

    def on_notifications_clearindicator(self, directive):
        """
        Handles lowering the flag when notifications aere cleared
        """
        self.outputToConsole("Cleared notification")
        self.setNotificationFlag(False)

    def on_custom_mindstorms_gadget_control(self, directive):
        """
        Handles the Custom.Mindstorms.Gadget control directive.
        :param directive: the custom directive with the matching namespace and name
        """
        try:
            inputRecognised = False

            # get the control type from the directive payload so we can act on it
            payload = json.loads(directive.payload.decode("utf-8"))
            print("Control payload: {}".format(payload))
            control_type = payload["type"]

            if control_type == "move":
                self.outputToConsole("We have a move request")

                # have we been asked to stop or move?
                if payload["direction"] in Direction.STOP.value:
                    self.tankDrive.off()
                    inputRecognised = True
                else:
                    self.move(payload["direction"], float(payload["distance"]), SPEED)
                    inputRecognised = True

            if control_type == "command":
                self.outputToConsole("We have a command to action")

                # have we been asked to tilt?
                if payload["command"] in Command.TILT.value:
                    self.tilt()
                    inputRecognised = True

                # have we been asked to print data?
                if payload["command"] in Command.PRINT_DATA.value:
                    self.printData()
                    inputRecognised = True

                # have we been asked to provide the battery level?
                if payload["command"] in Command.BATTERY.value:
                    self.getBatteryInfo()
                    inputRecognised = True

                # have we been asked to set the current location?
                if payload["command"] in Command.LOCATION_SET_CURRENT.value:
                    self.setCurrentLocation(payload["location"])
                    inputRecognised = True

                # have we been asked to save a location?
                if payload["command"] in Command.LOCATION_SAVE.value:
                    self.saveMovesAsLocation(payload["location"])
                    inputRecognised = True

                # have we been asked to go to a location?
                if payload["command"] in Command.LOCATION_GOTO.value:
                    self.moveFromAtoB(payload["location"])
                    inputRecognised = True

                # have we been asked to remove a location?
                if payload["command"] in Command.LOCATION_REMOVE.value:
                    self.removeLocation(payload["location"])
                    inputRecognised = True

                # have we been asked to power down?
                if payload["command"] in Command.POWER_DOWN.value:
                    self.powerDown = True
                    inputRecognised = True
                    subprocess.call(["sudo", "poweroff"])  # the NXT brick is on a 2 minute timeout without a keep alive so will power down a few minutes after this EV3 brick does

            # if we've moved somewhere and we've not detected something in the way then let the user know we're done
            if self.movedSomewhere and not self.forwardStop and not self.backwardStop:
                self.makeAlexaSpeak("Done")

            # if we didn't recognise the input then tell the user
            if not inputRecognised:
                self.makeAlexaSpeak("Sorry, I didn't understand that command")

        except KeyError:
            print("Missing expected parameters: {}".format(directive))

    def outputToConsole(self, outputData):
        """
        Output stuff to the console
        """
        print("\nLog: " + outputData + "\n")

    def makeAlexaSpeak(self, speech):
        """
        Send a custom event to the skill making Alexa say the given speech
        """
        print("\nAlexa: " + speech + "\n")
        self.send_custom_event("Custom.Mindstorms.Gadget", "Speech", {"speechOut": speech})

    def detection(self):
        """
        Detect edges and objects using the sensors
        """
        startTime = time.time()

        toldUserAboutForwardStop = False
        toldUserAboutBackwardStop = False

        while not self.powerDown:
            # keep the NXT brick on with a keep alive every 30 seconds (apparently getting a sample won't do, it needs a specific keep alive)
            if time.time() - startTime > 30:
                self.outputToConsole("Keeping the NXT brick alive ({})".format(datetime.now()))
                self.setTheTimeRecently = False
                self.nxtBrick.keep_alive()
                startTime = time.time()

            # get sensor data
            self.frontLeftNxtUltrasonicDistance = self.frontLeftNxtUltrasonic.distance_centimeters
            self.frontRightNxtUltrasonicDistance = self.frontRightNxtUltrasonic.distance_centimeters
            self.frontEv3InfraRedProximity = self.frontEv3InfraRed.proximity
            self.rearEv3ColourReflectedLight = self.rearEv3Colour.reflected_light_intensity
            self.nxtTiltButtonPressed = self.nxtTiltButton.get_sample()
            self.nxtFlagButtonPressed = self.nxtFlagButton.get_sample()

            # decide if forward movement is allowed
            if self.frontLeftNxtUltrasonicDistance > SURFACE_DISTANCE_MIN or self.frontRightNxtUltrasonicDistance > SURFACE_DISTANCE_MIN or self.frontEv3InfraRedProximity < PROXIMITY_DISTANCE_MIN:
                if not self.forwardStop:
                    self.printData()

                self.forwardStop = True
            else:
                self.forwardStop = False
                toldUserAboutForwardStop = False

            # decide if backward movement is allowed
            if self.rearEv3ColourReflectedLight < REFELECTED_LIGHT_MIN:
                if not self.backwardStop:
                    self.printData()

                self.backwardStop = True
            else:
                self.backwardStop = False
                toldUserAboutBackwardStop = False

            if self.forwardStop and not toldUserAboutForwardStop:
                if self.frontEv3InfraRedProximity < PROXIMITY_DISTANCE_MIN:
                    self.makeAlexaSpeak("Woah, there's something in the way")
                else:
                    self.makeAlexaSpeak("That was close!")
                toldUserAboutForwardStop = True

            if self.backwardStop and not toldUserAboutBackwardStop:
                self.makeAlexaSpeak("That was a near miss")
                toldUserAboutBackwardStop = True

            time.sleep(0.1)

        self.outputToConsole("Exiting edge and object detection loop")

    def move(self, direction, distance, speed):
        """
        Move the robot in the specified direction
        """
        DEGREES_OF_DRIVE_PER_CM = 35  # 350 degrees of drive is approx. 10cm so 35 degrees is approx. 1cm
        DEGREES_OF_DRIVE_TO_TURN_ONE_DEGREE = 5.22  # 470 degrees of drive on one motor gives a 90 degree turn so 5.22 degrees would give a 1 degree turn
        DEGREES_OF_DRIVE_TO_TURN_NINETY_DEGREES = 470

        self.outputToConsole("Move - Direction: {0}, Distance: {1}, Speed: {2}".format(direction, distance, speed))

        self.movedSomewhere = False

        # do we recognise the move?
        if (
            (direction not in Direction.FORWARD.value) and (direction not in Direction.BACKWARD.value) and (direction not in Direction.LEFT.value)
            and (direction not in Direction.RIGHT.value) and (direction not in Direction.STOP.value)
        ):
            self.makeAlexaSpeak("Direction not recognised")
            return

        # no negative distances allowed
        if float(distance) < 0:
            self.makeAlexaSpeak("Distance cannot be negative, the requested move will not be made")
            return

        # no negative speeds allowed
        if int(speed) < 0:
            self.makeAlexaSpeak("Speed cannot be negative, the requested move will not be made")
            return

        # record the starting degrees so that we can eventually record distance moved if required
        motorStartDegrees = self.largeMotorB.degrees

        # no moving while tilted so level off before moving if required
        if not self.nxtTiltButtonPressed:
            self.tilt()

        # stop if we've been asked to
        if direction in Direction.STOP.value and self.tankDrive.is_running:
            self.tankDrive.off()

        # move forward either the specified distance or while we can
        if direction in Direction.FORWARD.value and not self.forwardStop:
            self.currentLocationName = LOCATION_UNKNOWN
            self.movedSomewhere = True

            if distance != 0:
                degreesOfDrive = float(distance) * DEGREES_OF_DRIVE_PER_CM  # convert centimetres to degrees of drive
                self.tankDrive.on_for_degrees(speed, speed, degreesOfDrive, True, False)
            else:
                self.tankDrive.on(speed, speed)

            # wait till we're done moving
            while not self.forwardStop and not self.powerDown and self.tankDrive.is_running:
                time.sleep(0.1)

        # move backward either the specified distance or while we can
        if direction in Direction.BACKWARD.value and not self.backwardStop:
            self.currentLocationName = LOCATION_UNKNOWN
            self.movedSomewhere = True

            if distance != 0:
                degreesOfDrive = float(distance) * DEGREES_OF_DRIVE_PER_CM  # convert centimetres to degrees of drive
                self.tankDrive.on_for_degrees(-speed, -speed, degreesOfDrive, True, False)
            else:
                self.tankDrive.on(-speed, -speed)

            # wait till we're done moving
            while not self.backwardStop and not self.powerDown and self.tankDrive.is_running:
                time.sleep(0.1)

        # move left the specified degrees or 90 degrees
        if direction in Direction.LEFT.value and not self.forwardStop and not self.backwardStop:
            self.currentLocationName = LOCATION_UNKNOWN
            self.movedSomewhere = True

            if distance != 0:
                degreesOfDrive = float(distance) * DEGREES_OF_DRIVE_TO_TURN_ONE_DEGREE  # convert degrees to degrees of drive
                self.tankDrive.on_for_degrees(speed, -speed, degreesOfDrive, True, False)
            else:
                self.tankDrive.on_for_degrees(speed, -speed, DEGREES_OF_DRIVE_TO_TURN_NINETY_DEGREES, True, False)

            # wait till we're done moving
            while not self.forwardStop and not self.backwardStop and not self.powerDown and self.tankDrive.is_running:
                time.sleep(0.1)

        # move right the specified degrees or 90 degrees
        if direction in Direction.RIGHT.value and not self.forwardStop and not self.backwardStop:
            self.currentLocationName = LOCATION_UNKNOWN
            self.movedSomewhere = True

            if distance != 0:
                degreesOfDrive = float(distance) * DEGREES_OF_DRIVE_TO_TURN_ONE_DEGREE  # convert degrees to degrees of drive
                self.tankDrive.on_for_degrees(-speed, speed, degreesOfDrive, True, False)
            else:
                self.tankDrive.on_for_degrees(-speed, speed, DEGREES_OF_DRIVE_TO_TURN_NINETY_DEGREES, True, False)

            # wait till we're done moving
            while not self.forwardStop and not self.backwardStop and not self.powerDown and self.tankDrive.is_running:
                time.sleep(0.1)

        # and we're done moving
        if self.tankDrive.is_running:
            self.tankDrive.off()

        # add the move to the moves list
        if self.recordMoves:
            if self.forwardStop or self.backwardStop:
                if direction in Direction.FORWARD.value or direction in Direction.BACKWARD.value:
                    calculatedDistance = round((abs(self.largeMotorB.degrees - motorStartDegrees) / DEGREES_OF_DRIVE_PER_CM), 2)
                else:
                    calculatedDistance = round((abs(self.largeMotorB.degrees - motorStartDegrees) / DEGREES_OF_DRIVE_TO_TURN_ONE_DEGREE), 2)

                self.movesList.append(Move(direction=direction, distance=calculatedDistance, speed=speed))
            else:
                self.movesList.append(Move(direction=direction, distance=distance, speed=speed))

    def dance(self):
        """
        Make the stand do a short side to side dance
        """
        SMALL_MOVE = 6
        BIG_MOVE = 12
        MOVE_SPEED = 40

        # we don't want to record dance moves
        self.recordMoves = False

        # shimmy a bit to the left to the left
        self.move("left", SMALL_MOVE, MOVE_SPEED)

        # swing right and left
        moveCount = 0
        while moveCount < 4:
            self.move("right", BIG_MOVE, MOVE_SPEED)
            self.move("left", BIG_MOVE, MOVE_SPEED)
            moveCount += 1

        # shimmy a little left one last time to be back where we were (in theory ...)
        self.move("right", BIG_MOVE, MOVE_SPEED)
        self.move("left", SMALL_MOVE, MOVE_SPEED)

        # done dancing so let's record moves again
        self.recordMoves = True

    def setNotificationFlag(self, raiseFlag):
        """
        Raise or lower the notification flag
        """
        if raiseFlag and self.nxtFlagButtonPressed:
            self.nxtNotificationMotor.on_for_degrees(-10, 95)
            self.outputToConsole("Raising the flag")
        else:
            if not raiseFlag and not self.nxtFlagButtonPressed:
                self.nxtNotificationMotor.on_for_degrees(10, 95)
                self.outputToConsole("Lowering the flag")

    def runTimerSpinner(self, power):
        """
        Spin or stop the end of timer spinner
        """
        if power > 0:
            self.nxtTimerMotor.run(-power)
        else:
            self.nxtTimerMotor.idle()

    def tilt(self):
        """
        Raise or lower the Echo Show
        """
        # add the move to the moves list
        if self.recordMoves:
            self.movesList.append(Move(direction="tilt", distance=0, speed=0))

        # no tilting and driving at the same time
        self.tankDrive.off()

        # tilt the opposite way to the current tilt
        if self.nxtTiltButtonPressed:
            tiltDegrees = TILT_DEGREES
            self.tilted = True
            self.outputToConsole("Tilting up ...")
        else:
            tiltDegrees = -TILT_DEGREES
            self.tilted = False
            self.outputToConsole("Tilting down ...")

        # do the tilt
        self.mediumTiltMotor.on_for_degrees(20, tiltDegrees)
        self.mediumTiltMotor.off()

    def moveFromAtoB(self, locationName):
        """
        Handles getting the stand from A to B, including going home in between
        """

        self.movedSomewhere = False

        # can't go somewhere we don't recognise
        if locationName != LOCATION_HOME and not path.exists(locationName):
            self.makeAlexaSpeak("Hmm, I don't recognise a location called {}".format(locationName))
            return

        # can't go home if we're already home
        if self.currentLocationName == LOCATION_HOME and locationName == LOCATION_HOME:
            self.makeAlexaSpeak("We're already home")
            return

        # if we're home then go to the location, otherwise go home first
        if self.currentLocationName == LOCATION_HOME:
            self.gotoLocation(locationName)
        else:
            self.gotoLocation(LOCATION_HOME)
            self.gotoLocation(locationName)

    def gotoLocation(self, locationName):
        """
        Load the moves for the location and then do the moves
        """
        failedToExecuteMove = False
        moves = []
        haveValidMoves = False

        # we don't want to record moves while moving to a location as we already have the moves in the list
        self.recordMoves = False

        # if we're going home then reverse the moves list and swap forwards and backwards and left and right, otherwise load a moves list
        if locationName == LOCATION_HOME:
            haveValidMoves = True

            for move in reversed(self.movesList):

                if move.direction in Direction.FORWARD.value:
                    moves.append(Move(direction="backward", distance=move.distance, speed=move.speed))

                if move.direction in Direction.BACKWARD.value:
                    moves.append(Move(direction="forward", distance=move.distance, speed=move.speed))

                if move.direction in Direction.LEFT.value:
                    moves.append(Move(direction="right", distance=move.distance, speed=move.speed))

                if move.direction in Direction.RIGHT.value:
                    moves.append(Move(direction="left", distance=move.distance, speed=move.speed))

                if move.direction in Command.TILT.value:
                    moves.append(Move(direction=move.direction, distance=move.distance, speed=move.speed))
        else:
            if self.loadMovesAsLocation(locationName):
                moves = self.movesList
                haveValidMoves = True

        # if we have valid moves then get moving
        if haveValidMoves:
            for move in moves:
                self.outputToConsole("Direction: {0}, Distance: {1}, Speed: {2}".format(move.direction, move.distance, move.speed))

                # we can either tilt or move
                if move.direction in Command.TILT.value:
                    self.tilt()
                else:
                    self.move(move.direction, move.distance, move.speed)

                # if we've found an edge or something in the way and the move was for a specified distance then we likely haven't made it to the location
                if (self.forwardStop or self.backwardStop) and move.distance != 0:
                    failedToExecuteMove = True

            # record that we got there if we did
            if not failedToExecuteMove:
                self.currentLocationName = locationName
            else:
                self.currentLocationName = LOCATION_UNKNOWN

            # if we went home then clear the moves list
            if locationName == LOCATION_HOME:
                self.movesList.clear()

        # we've moved to the location so we can record moves again
        self.recordMoves = True

    def saveMovesAsLocation(self, locationName):
        """
        Saves the currently recorded moves as a JSON file and then clears the moves list
        """

        # don't allow an empty location name
        if locationName == "":
            self.makeAlexaSpeak("You haven't specified a location name")
            return

        # don't allow "home" to be specified as a location
        if locationName == LOCATION_HOME:
            self.makeAlexaSpeak("Home is built in and cannot be used as a name for a custom location")
            return

        # ditch the file if it exists
        if path.exists(locationName):
            self.outputToConsole("Deleting existing location file")
            os.remove(locationName)

        # save the moves list as a JSON file
        with open(locationName, "w") as file:
            json.dump(Location(self.movesList), file, default=lambda o: o.__dict__, sort_keys=False, indent=4)

        # set the current location to the one we've just saved
        self.currentLocationName = locationName

        self.makeAlexaSpeak("Location saved as {}".format(locationName))

    def loadMovesAsLocation(self, locationName):
        """
        Loads the moves from the given JSON file name
        """
        if path.exists(locationName):
            self.currentLocationName = locationName

            with open(locationName, "r") as file:
                self.movesList = Location.from_json(json.load(file)).moves

            self.outputToConsole("Loaded location")
            return True
        else:
            self.makeAlexaSpeak("Hmm, I don't recognise a location called {}".format(locationName))
            return False

    def setCurrentLocation(self, locationName):
        """
        Sets the current location and loads the moves list if not the home location
        """
        self.movedSomewhere = False

        # don't allow an empty location name
        if locationName == "":
            self.makeAlexaSpeak("You haven't specified a location name")
            return

        # nothing to load if the location is home
        if locationName == LOCATION_HOME:
            self.currentLocationName = locationName
            self.movesList.clear()
            self.makeAlexaSpeak("Location set to home")
            return

        # load the location if found
        if path.exists(locationName):
            self.currentLocationName = locationName
            self.loadMovesAsLocation(locationName)
            self.makeAlexaSpeak("Location set to {}".format(locationName))
        else:
            self.currentLocationName = LOCATION_UNKNOWN
            self.makeAlexaSpeak("Hmm, I don't recognise a location called {}".format(locationName))

    def removeLocation(self, locationName):
        """
        Delete the specified location file
        """
        self.movedSomewhere = False

        # don't allow an empty location name
        if locationName == "":
            self.makeAlexaSpeak("You haven't specified a location name")
            return

        # don't allow "home" to be specified as a location
        if locationName == LOCATION_HOME:
            self.makeAlexaSpeak("Home is a built in location and cannot be removed")
            return

        if path.exists(locationName):
            os.remove(locationName)
            self.makeAlexaSpeak("Deleted location {}".format(locationName))
        else:
            self.makeAlexaSpeak("Hmm, I don't recognise a location called {}".format(locationName))

    def printMoves(self):
        """
        Print the recorded moves
        """
        self.movedSomewhere = False

        print("Current Location: {}".format(self.currentLocationName))

        for move in self.movesList:
            print("Direction: {0}, Distance: {1}, Speed: {2}".format(move.direction, move.distance, move.speed))

    def getBatteryInfo(self):
        """
        Return battery info
        """
        self.movedSomewhere = False

        batteryInfo = "My little helper's main battery level is {0:.2f} Volts and it's secondary battery level is {1:.2f} Volts.".format(self.powerSupply.measured_volts, (self.nxtBrick.get_battery_level() / 1000))

        self.makeAlexaSpeak(batteryInfo)

    def printData(self):
        """
        Print the latest data
        """
        print(
            "Front Left US (cm): {0}, Front Right US (cm): {1}, Front IR (cm) {2}, Rear Light (%): {3:.2f}, Tilt Button State: {4}, Flag Button State: {5}, Forward Stop: {6}, Backward Stop: {7}".format(
                self.frontLeftNxtUltrasonicDistance,
                self.frontRightNxtUltrasonicDistance,
                self.frontEv3InfraRedProximity,
                self.rearEv3ColourReflectedLight,
                self.nxtTiltButtonPressed,
                self.nxtFlagButtonPressed,
                self.forwardStop,
                self.backwardStop,
            )
        )

        self.printMoves()


if __name__ == "__main__":
    # Startup sequence
    gadget = MindstormsGadget()
    gadget.sound.set_volume(5, "Beep")

    # Gadget main entry point
    gadget.main()

    # Shutdown sequence
    gadget.sound.play_song((("E5", "e"), ("C4", "e")))