def main(): root = tkinter.Tk() root.title = "MQTT Shared Circles" main_frame = ttk.Frame(root, padding=5) main_frame.grid() instructions = "Click the window to make a circle" label = ttk.Label(main_frame, text=instructions) label.grid(columnspan=2) # Make a tkinter.Canvas on a Frame. canvas = tkinter.Canvas(main_frame, background="lightgray", width=800, height=500) canvas.grid(columnspan=2) # Make callbacks for mouse click events. canvas.bind("<Button-1>", lambda event: left_mouse_click(event, mqtt_client)) # Make callbacks for the two buttons. clear_button = ttk.Button(main_frame, text="Clear") clear_button.grid(row=3, column=0) clear_button["command"] = lambda: clear(canvas) quit_button = ttk.Button(main_frame, text="Quit") quit_button.grid(row=3, column=1) quit_button["command"] = lambda: quit_program(mqtt_client) # Create an MQTT connection # DONE: 5. Delete the line below (mqtt_client = None) then uncomment the code below. It creates a real mqtt client. my_delegate = MyDelegate(canvas) mqtt_client = com.MqttClient(my_delegate) mqtt_client.connect("draw", "draw") root.mainloop()
def main(): print("--------------------------------------------") print(" Pixy display") print(" Press the touch sensor to exit") print("--------------------------------------------") ev3.Sound.speak("Pixy display").wait() print("Press the touch sensor to exit this program.") # DONE: 2. Create an MqttClient (no delegate needed since EV3 will only send data, so an empty constructor is fine) # Then connect to the pc using the connect_to_pc method. robot = robo.Snatch3r() robot.pixy.mode = "SIG1" mqtt_client = com.MqttClient() mqtt_client.connect_to_pc() while not robot.touch_sensor.is_pressed: # DONE: 3. Read the Pixy values for x, y, width, and height # Print the values (much like the print_pixy_readings example) x = robot.pixy.value(1) y = robot.pixy.value(2) width = robot.pixy.value(3) height = robot.pixy.value(4) print("value1: X", robot.pixy.value(1)) print("value2: Y", robot.pixy.value(2)) print("value3: Width", robot.pixy.value(3)) print("value4: Height", robot.pixy.value(4)) # DONE: 4. Send the Pixy values to the PC by calling the on_rectangle_update method # If you open m2_pc_pixy_display you can see the parameters for that method [x, y, width, height] mqtt_client.send_message("on_rectangle_update", [x, y, width, height]) time.sleep(0.25) print("Goodbye!") ev3.Sound.speak("Goodbye").wait() mqtt_client.close()
def main(): print("--------------------------------------------") print(" Pixy display") print(" Press the touch sensor to exit") print("--------------------------------------------") ev3.Sound.speak("Pixy display").wait() print("Press the touch sensor to exit this program.") # DONE: 2. Create an MqttClient (no delegate needed since EV3 will only send data, so an empty constructor is fine) # Then connect to the pc using the connect_to_pc method. mqtt_client = com.MqttClient( ) #Sets up a MQTT client to communicate with EV3 mqtt_client.connect_to_pc() robot = robo.Snatch3r() robot.pixy.mode = "SIG1" while not robot.touch_sensor.is_pressed: # DONE: 3. Read the Pixy values for x, y, width, and height # Print the values (much like the print_pixy_readings example) x = robot.pixy.value( 1 ) #Gathers and stores the values form the pixy camera for later use y = robot.pixy.value(2) width = robot.pixy.value(3) height = robot.pixy.value(4) print("(X, Y)= ({}, {}) Width={} Height={}".format( x, y, width, height)) # DONE: 4. Send the Pixy values to the PC by calling the on_rectangle_update method # If you open m2_pc_pixy_display you can see the parameters for that method [x, y, width, height] mqtt_client.send_message('on_rectangle_update', [x, y, width, height]) time.sleep(0.25) print("Goodbye!") ev3.Sound.speak("Ciao").wait() mqtt_client.close()
def main(): # -------------------------------------------------------------------------- # DONE: 3. Construct a Snatch3rRobot. Test. When OK, delete this TODO. # -------------------------------------------------------------------------- robot = rb.Snatch3rRobot() # -------------------------------------------------------------------------- # TODO: 4. Add code that constructs a com.MqttClient that will # TODO: be used to receive commands sent by the laptop. # TODO: Connect it to this robot. Test. When OK, delete this TODO. # -------------------------------------------------------------------------- rc = RemoteControlETC(robot) mqtt_client = com.MqttClient(rc) mqtt_client.connect_to_pc() # -------------------------------------------------------------------------- # TODO: 5. Add a class for your "delegate" object that will handle messages # TODO: sent from the laptop. Construct an instance of the class and # TODO: pass it to the MqttClient constructor above. Augment the class # TODO: as needed for that, and also to handle the go_forward message. # TODO: Test by PRINTING, then with robot. When OK, delete this TODO. # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # TODO: 6. With your instructor, discuss why the following WHILE loop, # TODO: that appears to do nothing, is necessary. # TODO: When you understand this, delete this TODO. # -------------------------------------------------------------------------- while True: # ---------------------------------------------------------------------- # TODO: 7. Add code that makes the robot beep if the top-red button # TODO: on the Beacon is pressed. Add code that makes the robot # TODO: speak "Hello. How are you?" if the top-blue button on the # TODO: Beacon is pressed. Test. When done, delete this TODO. # ---------------------------------------------------------------------- time.sleep(0.01) # For the delegate to do its work if robot.beacon_button_sensor.is_top_red_button_pressed(): ev3.Sound.beep().wait()
def main(): root = tkinter.Tk() my_delegate = MyDelegate() mqtt_client = com.MqttClient(my_delegate) mqtt_client.connect_to_ev3() root.title("Robit") style = ttk.Style() label0 = ttk.Label(root, text=" ", font=('Helvetica', 10)) label0.grid(row=0, column=0) label1 = ttk.Label(root, text="What do you want Robit to do?", font=("Helvetica", 17)) label1.grid(row=2, column=0) style.configure('my.TFrame', background='#a8c9ff') frame1 = ttk.Frame(root, style='my.TFrame', padding=70) frame1.grid() command(frame1, root, mqtt_client) root.mainloop()
def select_color_window(): mqtt_client = com.MqttClient() mqtt_client.connect_to_ev3() root = tkinter.Tk() root.title("Select Color") colors_frame = ttk.Frame(root, padding=20, relief='raised') colors_frame.grid() red_button = ttk.Button(colors_frame, text='Red') red_button.grid(row=1, column=1) red_button['command'] = lambda: set_color(mqtt_client, red, "red") green_button = ttk.Button(colors_frame, text='Green') green_button.grid(row=1, column=2) green_button['command'] = lambda: set_color(mqtt_client, green, "green") black_button = ttk.Button(colors_frame, text='Black') black_button.grid(row=1, column=3) black_button['command'] = lambda: set_color(mqtt_client, black, "black") root.mainloop()
def main(): print("--------------------------------------------") print(" LED Button communication") print(" Press Back to exit when done.") print("--------------------------------------------") ev3.Sound.speak("LED Button communication").wait() # TODO: 3. Create an instance of your delegate class and an MQTT client, passing in the delegate object. # Note: you can determine the variable names that you should use by looking at the errors underlined in later code. # Once you have that done connect the mqtt_client to the MQTT broker using the connect_to_pc method. # Note: on EV3 you call connect_to_pc, but in the PC code it will call connect_to_ev3 my_delegate = MyDelegate() mqtt_client = com.MqttClient(my_delegate) mqtt_client.connect_to_pc() # Buttons on EV3 (these obviously assume TO DO: 3. is done) btn = ev3.Button() btn.on_up = lambda state: handle_button_press(state, mqtt_client, "Up") btn.on_down = lambda state: handle_button_press(state, mqtt_client, "Down") btn.on_left = lambda state: handle_button_press(state, mqtt_client, "Left") btn.on_right = lambda state: handle_button_press(state, mqtt_client, "Right") btn.on_backspace = lambda state: handle_shutdown(state, my_delegate) while my_delegate.running: btn.process() time.sleep(0.01) ev3.Sound.speak("Goodbye").wait() ev3.Leds.set_color(ev3.Leds.LEFT, ev3.Leds.GREEN) ev3.Leds.set_color(ev3.Leds.RIGHT, ev3.Leds.GREEN)
def main(): robot = robo.Snatch3r() mqtt_client = com.MqttClient(robot) mqtt_client.connect_to_pc() touch_sensor = ev3.TouchSensor() assert touch_sensor ev3.Sound.speak('Guide me back home').wait() mqtt_client.send_message('msg', ['Guide me back home']) while True: if robot.color_sensor.color == ev3.ColorSensor.COLOR_BLUE: robot.drive_stop() robot.turn_degrees(380, 300) time.sleep(3) if robot.color_sensor.color == ev3.ColorSensor.COLOR_RED: robot.drive_stop() ev3.Sound.speak('you just killed me').wait() mqtt_client.send_message('msg', ['you just killed me']) robot.arm_down() exit() if robot.color_sensor.color == ev3.ColorSensor.COLOR_YELLOW: robot.drive_stop() ev3.Sound.play( "/home/robot/csse120/assets/sounds/awesome_pcm.wav").wait() time.sleep(3) while not touch_sensor.is_pressed: time.sleep(5) ev3.Sound.speak('I am home').wait() mqtt_client.send_message('msg', ['I am home']) time.sleep(1) ev3.Sound.speak('Here is the bone').wait() mqtt_client.send_message('msg', ['Here is the bone']) exit() robot.loop_forever()
def main(): robot = robo.Snatch3r() mqtt_client = com.MqttClient(robot) mqtt_client.connect_to_pc() btn = ev3.Button() btn.process() while True: if btn.left: print("left") ev3.Leds.set_color(ev3.Leds.LEFT, ev3.Leds.GREEN) ev3.Leds.set_color(ev3.Leds.RIGHT, ev3.Leds.BLACK) # if the right button is pressed, print "right" and turn on the right LED set to red if btn.right: # an if statement is used because more than one button can be pressed at a time print("right") ev3.Leds.set_color(ev3.Leds.RIGHT, ev3.Leds.RED) ev3.Leds.set_color(ev3.Leds.LEFT, ev3.Leds.BLACK) # if the up button is pressed, print "up" and turn all LEDs off if btn.up: print("up") ev3.Leds.all_off() print(robot.color_sensor.color, robot.color_sensor.reflected_light_intensity) if robot.color_sensor.color == 1: mqtt_client.send_message("change_points", 10) if robot.touch_sensor.is_pressed: ev3.Sound.speak("Done") if btn.backspace: break time.sleep( 0.01 ) # Best practice to have a short delay to avoid working too hard between loop iterations. # Best practice to leave the LEDs on after you finish a program so you don't put away the robot while still on. ev3.Leds.set_color(ev3.Leds.LEFT, ev3.Leds.GREEN) ev3.Leds.set_color(ev3.Leds.RIGHT, ev3.Leds.GREEN) robot.loop_forever( ) # Calls a function that has a while True: loop within it to avoid letting the program end.
def main(): """ This code, which must run on a LAPTOP: 1. Constructs a GUI for my part of the Capstone Project. 2. Communicates via MQTT with the code that runs on the EV3 robot. """ # ------------------------------------------------------------------------- # Construct and connect the MQTT Client: # ------------------------------------------------------------------------- mqtt_sender = com.MqttClient() mqtt_sender.connect_to_ev3() # ------------------------------------------------------------------------- # The root TK object for the GUI: # ------------------------------------------------------------------------- root = tkinter.Tk() root.title("CSSE 120 Capstone Project") # ------------------------------------------------------------------------- # The main frame, upon which the other frames are placed. # ------------------------------------------------------------------------- main_frame = ttk.Frame(root) main_frame.grid() # ------------------------------------------------------------------------- # Grid the frames. # ------------------------------------------------------------------------- # grid_frames(teleop_frame, arm_frame, control_frame, movement_frame, noise_frame) get_user_controlled_dance_frame(main_frame, mqtt_sender).grid(row=0, column=0) get_automatic_dance_frame(main_frame, mqtt_sender).grid(row=1, column=0) # ------------------------------------------------------------------------- # The event loop: # ------------------------------------------------------------------------- root.mainloop()
def main(): ev3.Sound.speak("Avoid collision system activated").wait() left_motor = ev3.LargeMotor(ev3.OUTPUT_B) right_motor = ev3.LargeMotor(ev3.OUTPUT_C) assert left_motor.connected assert right_motor.connected # Robot robot = robo.Snatch3r() # Remote control mqtt_client = com.MqttClient(robot) mqtt_client.connect_to_pc() while not robot.touch_sensor.is_pressed: while robot.active is True: if robot.ir_sensor.proximity <= 40: robot.left_motor.stop(stop_action=ev3.Motor.STOP_ACTION_COAST) robot.right_motor.stop(stop_action=ev3.Motor.STOP_ACTION_COAST) time.sleep(1) robot.turn_degrees(90, 200) else: left_motor.run_forever(speed_sp=400) right_motor.run_forever(speed_sp=400) robot.stop() time.sleep(0.1)
def main(): """ This code, which must run on a LAPTOP: 1. Constructs a GUI for my part of the Capstone Project. 2. Communicates via MQTT with the code that runs on the EV3 robot. """ # ------------------------------------------------------------------------- # Construct and connect the MQTT Client: # ------------------------------------------------------------------------- # ROOT ONE LOSE root1 = tkinter.Tk() laptop_handler_lose = Laptop_handler(root1) mqtt_sender = com.MqttClient(laptop_handler_lose) mqtt_sender.connect_to_ev3() root = tkinter.Toplevel() root.title("CSSE 120 Capstone Project, Winter 2018-19, Robot 11") # # ROOT TWO WIN # root2 = tkinter.Toplevel() main_frame = ttk.Frame(root, padding=10, borderwidth=5, relief='groove') main_frame.grid() # laptop_handler_lose = Laptop_handler(root1) # laptop_handler_win = Laptop_handler(root2) # laptop_handler_lose.window_two(root1) # laptop_handler_win.window_one(root2) teleop_frame, arm_frame, control_frame, drive_system_frame, haiden_frame, mario_frame = get_shared_frames( main_frame, mqtt_sender) grid_frames(teleop_frame, arm_frame, control_frame, drive_system_frame, haiden_frame, mario_frame) root.mainloop()
def main(): my_delegate = MyDelegate() mqtt_client = com.MqttClient(my_delegate) mqtt_client.connect_to_ev3() root = tkinter.Tk() root.title(" Pokemon Red: Remastered Edition") party = tkinter.Toplevel() walk_speed = 500 charmander = Pokemon() charmander.type = "Fire" squirtle = Pokemon() squirtle.type = "Water" bulbasaur = Pokemon() bulbasaur.type = "Grass" start_window(root) movement(party, mqtt_client, walk_speed) party_window(party, mqtt_client, charmander, squirtle, bulbasaur) root.mainloop()
def __init__(self): delegate = delegate_on_laptop() self.mqtt_sender = com.MqttClient(delegate) self.mqtt_sender.connect_to_ev3() # Declaring variables self.time_initial = time.time() self.energy = 100 self.speed = 0 self.root = tkinter.Tk() self.root.title('CSSE120 Capstone Project') self.main_frame = ttk.Frame(self.root, padding=10, borderwidth=5, relief='groove') self.main_frame.grid() # Creates the title frame self.title_frame = ttk.Frame(self.main_frame, padding=10, borderwidth=5, relief="ridge") title_label = tkinter.Label(self.title_frame, text='ROBO-KART', font=("Cooper Black", 33), fg='goldenrod') title_label.grid() self.create_play_frame() # Grids title and play frame onto the main frame self.title_frame.grid(row=0, column=0) self.play_frame.grid(row=1, column=0) self.bind_keys()
def the_computer_can_receive_messages_too(): """ Showing an example of a PC receiving a message. This code is similar to turnerwb but not identical, so don't copy anything from here except maybe the words: mqtt_client.send_message("on_circle_draw", [ ]) """ # Make a quick custom class. class MyDelegate(object): def __init__(self, canvas): self.canvas = canvas def on_circle_draw(self, color, x, y): self.canvas.create_oval(x - 10, y - 10, x + 10, y + 10, fill=color, width=3) canvas = "A Tkinter object" # Something specific to the m1_pc_shared_circles example. my_delegate = MyDelegate(canvas) mqtt_client = com.MqttClient(my_delegate) mqtt_client.connect("draw", "draw") time.sleep(2) mqtt_client.send_message("on_circle_draw", ['blue', 50, 50]) time.sleep(5) mqtt_client.close()
def main(): root = tkinter.Tk() root.title = "Pixy display" main_frame = ttk.Frame(root, padding=5) main_frame.grid() # The values from the Pixy range from 0 to 319 for the x and 0 to 199 for the y. canvas = tkinter.Canvas(main_frame, background="lightgray", width=320, height=200) canvas.grid(columnspan=2) rect_tag = canvas.create_rectangle(150, 90, 170, 110, fill="blue") # Buttons for quit and exit quit_button = ttk.Button(main_frame, text="Quit") quit_button.grid(row=3, column=1) quit_button["command"] = lambda: quit_program(mqtt_client) # Create an MQTT connection my_delegate = MyDelegate(canvas, rect_tag) mqtt_client = com.MqttClient(my_delegate) # mqtt_client.connect_to_ev3() mqtt_client.connect_to_ev3("35.194.247.175") # Off campus IP address of a GCP broker root.mainloop()
def main(): """ This code, which must run on the EV3 ROBOT: 1. Makes the EV3 robot to various things. 2. Communicates via MQTT with the GUI code that runs on the LAPTOP. """ robot = rosebot.RoseBot() delegate = shared_gui_delegate_on_robot.Handler(robot) mqtt_receiver = com.MqttClient(delegate) mqtt_receiver.connect_to_pc() while True: time.sleep(0.04) if delegate.is_time_to_stop: break robot.sensor_system.camera.set_signature('SIG4') #print(robot.sensor_system.camera.get_biggest_blob()) mqtt_receiver.send_message("display_camera", [ robot.sensor_system.camera.get_biggest_blob().center.x, robot.sensor_system.camera.get_biggest_blob().center.y, robot.sensor_system.camera.get_biggest_blob().height, robot.sensor_system.camera.get_biggest_blob().width ])
def main(): """ This code, which must run on a LAPTOP: 1. Constructs a GUI for my part of the Capstone Project. 2. Communicates via MQTT with the code that runs on the EV3 robot. """ # ------------------------------------------------------------------------- # Construct and connect the MQTT Client: # ------------------------------------------------------------------------- laptop_delegate = m1.DelegateLaptop() mqtt_sender = com.MqttClient(laptop_delegate) mqtt_sender.connect_to_ev3() # ------------------------------------------------------------------------- # The root TK object for the GUI: # ------------------------------------------------------------------------- # root = tkinter.Tk() # root.title("CSSE 120 Capstone Project") # # personal_root = tkinter.Tk() # personal_root.title("Personal Feature") sprint3_root = tkinter.Tk() sprint3_root.title("Metal-and-Oil Detector") sprint3_root.configure(background="cornflower blue") sprint3_root.geometry("337x340") # ------------------------------------------------------------------------- # The main frame, upon which the other frames are placed. # ------------------------------------------------------------------------- # main_frame = ttk.Frame(root, padding=10) # main_frame.grid() # ------------------------------------------------------------------------- # Sub-frames for the shared GUI that the team developed: # ------------------------------------------------------------------------- # teleop_frame, arm_frame, control_frame, drive_system_frame, sound_system_frame, \ # ColorSensor_driving_frame, IR_driving_frame, camera_frame = get_shared_frames(main_frame, mqtt_sender) # ------------------------------------------------------------------------- # Frames that are particular to my individual contributions to the project. # ------------------------------------------------------------------------- # DONE: Implement and call get_my_frames(...) # m1_get_my_frame(personal_root, mqtt_sender) m1_sprint3_get_my_frame(sprint3_root, mqtt_sender) # ------------------------------------------------------------------------- # Grid the frames. # ------------------------------------------------------------------------- # grid_frames(teleop_frame, arm_frame, control_frame, drive_system_frame, sound_system_frame, # ColorSensor_driving_frame, IR_driving_frame, camera_frame) # ------------------------------------------------------------------------- # The event loop: # ------------------------------------------------------------------------- # root.mainloop() sprint3_root.mainloop()
def main(): my_pc_delegate = MyDelegateOnPc() mqtt_client = com.MqttClient(my_pc_delegate) mqtt_client.connect_to_ev3() root = tkinter.Tk() root.title("Satellite Remote Drive") main_frame = ttk.Frame(root, padding=20) main_frame.grid() left_speed_label = ttk.Label(main_frame, text="Left") left_speed_label.grid(row=0, column=0) left_speed_entry = ttk.Entry(main_frame, width=10) left_speed_entry.grid(row=1, column=0) right_speed_label = ttk.Label(main_frame, text="Right") right_speed_label.grid(row=0, column=2) right_speed_entry = ttk.Entry(main_frame, width=10) right_speed_entry.grid(row=1, column=2) forward_button = ttk.Button(main_frame, text="Forward") forward_button.grid(row=2, column=1) forward_button['command'] = lambda: callback_forward( mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Up>', lambda event: callback_forward(mqtt_client, left_speed_entry, right_speed_entry)) left_button = ttk.Button(main_frame, text="Left") left_button.grid(row=3, column=0) left_button['command'] = lambda: callback_left( mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Left>', lambda event: callback_left(mqtt_client, left_speed_entry, right_speed_entry)) right_button = ttk.Button(main_frame, text="Right") right_button.grid(row=3, column=2) right_button['command'] = lambda: callback_right( mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Right>', lambda event: callback_right(mqtt_client, left_speed_entry, right_speed_entry)) back_button = ttk.Button(main_frame, text="Back") back_button.grid(row=4, column=1) back_button['command'] = lambda: callback_back( mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Down>', lambda event: callback_back(mqtt_client, left_speed_entry, right_speed_entry)) stop_button = ttk.Button(main_frame, text="Stop") stop_button.grid(row=3, column=1) stop_button['command'] = lambda: callback_stop(mqtt_client) root.bind('<space>', lambda event: callback_stop(mqtt_client)) up_button = ttk.Button(main_frame, text="Up") up_button.grid(row=5, column=0) up_button['command'] = lambda: send_up(mqtt_client) root.bind('<u>', lambda event: send_up(mqtt_client)) down_button = ttk.Button(main_frame, text="Down") down_button.grid(row=6, column=0) down_button['command'] = lambda: send_down(mqtt_client) root.bind('<j>', lambda event: send_down(mqtt_client)) q_button = ttk.Button(main_frame, text="Quit") q_button.grid(row=5, column=2) q_button['command'] = (lambda: quit_program(mqtt_client, False)) e_button = ttk.Button(main_frame, text="Exit") e_button.grid(row=6, column=2) e_button['command'] = (lambda: quit_program(mqtt_client, True)) root.mainloop()
def main(): robot = robo.Snatch3r() mqtt_client = com.MqttClient(robot) mqtt_client.connect_to_pc() robot.loop_forever()
def main(): # Done: 2. Setup an mqtt_client. Notice that since you don't need to receive any messages you do NOT need to have # a MyDelegate class. Simply construct the MqttClient with no parameter in the constructor (easy). mqtt_client = com.MqttClient() mqtt_client.connect_to_ev3() root = tkinter.Tk() root.title("MQTT Remote") main_frame = ttk.Frame(root, padding=20, relief='raised') main_frame.grid() left_speed_label = ttk.Label(main_frame, text="Left") left_speed_label.grid(row=0, column=0) left_speed_entry = ttk.Entry(main_frame, width=8) left_speed_entry.insert(0, "600") left_speed_entry.grid(row=1, column=0) right_speed_label = ttk.Label(main_frame, text="Right") right_speed_label.grid(row=0, column=2) right_speed_entry = ttk.Entry(main_frame, width=8, justify=tkinter.RIGHT) right_speed_entry.insert(0, "600") right_speed_entry.grid(row=1, column=2) # Done: 3. Implement the callbacks for the drive buttons. Set both the click and shortcut key callbacks. # # To help get you started the arm up and down buttons have been implemented. # You need to implement the five drive buttons. One has been writen below to help get you started but is commented # out. You will need to change some_callback1 to some better name, then pattern match for other button / key combos. forward_button = ttk.Button(main_frame, text="Forward") forward_button.grid(row=2, column=1) # forward_button and '<Up>' key is done for your here... forward_button['command'] = lambda: drive_forward( mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Up>', lambda event: drive_forward(mqtt_client, left_speed_entry, right_speed_entry)) left_button = ttk.Button(main_frame, text="Left") left_button.grid(row=3, column=0) # left_button and '<Left>' key left_button['command'] = lambda: turn_left(mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Left>', lambda event: turn_left(mqtt_client, left_speed_entry, right_speed_entry)) stop_button = ttk.Button(main_frame, text="Stop") stop_button.grid(row=3, column=1) # stop_button and '<space>' key (note, does not need left_speed_entry, right_speed_entry) stop_button['command'] = lambda: stop(mqtt_client) root.bind('<space>', lambda event: stop(mqtt_client)) right_button = ttk.Button(main_frame, text="Right") right_button.grid(row=3, column=2) # right_button and '<Right>' key right_button['command'] = lambda: turn_right(mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Right>', lambda event: turn_right(mqtt_client, left_speed_entry, right_speed_entry)) back_button = ttk.Button(main_frame, text="Back") back_button.grid(row=4, column=1) # back_button and '<Down>' key back_button['command'] = lambda: drive_back(mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Down>', lambda event: drive_back(mqtt_client, left_speed_entry, right_speed_entry)) up_button = ttk.Button(main_frame, text="Up") up_button.grid(row=5, column=0) up_button['command'] = lambda: send_up(mqtt_client) root.bind('<u>', lambda event: send_up(mqtt_client)) down_button = ttk.Button(main_frame, text="Down") down_button.grid(row=6, column=0) down_button['command'] = lambda: send_down(mqtt_client) root.bind('<j>', lambda event: send_down(mqtt_client)) # Buttons for quit and exit q_button = ttk.Button(main_frame, text="Quit") q_button.grid(row=5, column=2) q_button['command'] = (lambda: quit_program(mqtt_client, False)) e_button = ttk.Button(main_frame, text="Exit") e_button.grid(row=6, column=2) e_button['command'] = (lambda: quit_program(mqtt_client, True)) root.mainloop()
def main(): """Makes a gui that controls the robot""" robot_to_computer = PictureToComputer() mqtt_client = com.MqttClient(robot_to_computer) mqtt_client.connect_to_ev3() root = tkinter.Tk() root.title("Let's Play Mario") main_frame = ttk.Frame(root, padding=20, relief='raised') main_frame.grid() left_speed_label = ttk.Label(main_frame, text="Left") left_speed_label.grid(row=0, column=0) left_speed_entry = ttk.Entry(main_frame, width=8) left_speed_entry.insert(0, "300") left_speed_entry.grid(row=1, column=0) right_speed_label = ttk.Label(main_frame, text="Right") right_speed_label.grid(row=0, column=2) right_speed_entry = ttk.Entry(main_frame, width=8, justify=tkinter.RIGHT) right_speed_entry.insert(0, "300") right_speed_entry.grid(row=1, column=2) forward_button = ttk.Button(main_frame, text="Forward") forward_button.grid(row=2, column=1) forward_button['command'] = lambda: send_forward(mqtt_client, left_speed_entry, right_speed_entry) root.bind('<Up>', lambda event: send_forward(mqtt_client, left_speed_entry, right_speed_entry)) left_button = ttk.Button(main_frame, text="Left") left_button.grid(row=3, column=0) left_button['command'] = lambda: send_left(mqtt_client, left_speed_entry, right_speed_entry) root.bind('<Left>', lambda event: send_left(mqtt_client, left_speed_entry, right_speed_entry)) stop_button = ttk.Button(main_frame, text="Stop") stop_button.grid(row=3, column=1) stop_button['command'] = lambda: send_stop(mqtt_client) root.bind('<space>', lambda event: send_stop(mqtt_client)) right_button = ttk.Button(main_frame, text="Right") right_button.grid(row=3, column=2) right_button['command'] = lambda: send_right(mqtt_client, left_speed_entry, right_speed_entry) root.bind('<Right>', lambda event: send_right(mqtt_client, left_speed_entry, right_speed_entry)) back_button = ttk.Button(main_frame, text="Back") back_button.grid(row=4, column=1) back_button['command'] = lambda: send_back(mqtt_client, left_speed_entry, right_speed_entry) root.bind('<Down>', lambda event: send_back(mqtt_client, left_speed_entry, right_speed_entry)) up_button = ttk.Button(main_frame, text="Up") up_button.grid(row=5, column=0) up_button['command'] = lambda: send_up(mqtt_client) root.bind('<u>', lambda event: send_up(mqtt_client)) down_button = ttk.Button(main_frame, text="Down") down_button.grid(row=6, column=0) down_button['command'] = lambda: send_down(mqtt_client) root.bind('<j>', lambda event: send_down(mqtt_client)) q_button = ttk.Button(main_frame, text="Quit") q_button.grid(row=5, column=2) q_button['command'] = (lambda: quit_program(mqtt_client, False)) e_button = ttk.Button(main_frame, text="Exit") e_button.grid(row=6, column=2) e_button['command'] = (lambda: quit_program(mqtt_client, True)) root.mainloop()
def main(): dc = DataContainer() mydelegate = MyDelegatePC() mqtt_client = com.MqttClient(mydelegate) mqtt_client.connect_to_ev3() dc.running = True root = tkinter.Tk() root.title("THE HUNT") main_frame = ttk.Frame(root, padding=20, relief='raised') main_frame.grid() left_speed = 400 right_speed = 400 hunt_photo = tkinter.PhotoImage(file='The_Hunt (1).gif') hunt_button = ttk.Button(main_frame, image=hunt_photo) hunt_button.image = hunt_photo hunt_button.grid(row=1, column=4) hunt_button['command'] = lambda: print("Are you ready to join THE HUNT?") forward_button = ttk.Button(main_frame, text="Forward") forward_button.grid(row=3, column=2) forward_button['command'] = lambda: forward_callback(mqtt_client, left_speed, right_speed) root.bind('<Up>', lambda event: forward_callback(mqtt_client, left_speed, right_speed)) down_button = ttk.Button(main_frame, text="Reverse") down_button.grid(row=5, column=2) down_button['command'] = lambda: backward_callback(mqtt_client, left_speed, right_speed) root.bind('<Down>', lambda event: backward_callback(mqtt_client, left_speed, right_speed)) left_button = ttk.Button(main_frame, text="Left") left_button.grid(row=4, column=1) left_button['command'] = lambda: left_callback(mqtt_client, left_speed, right_speed) root.bind('<Left>', lambda event: left_callback(mqtt_client, left_speed, right_speed)) right_button = ttk.Button(main_frame, text="Right") right_button.grid(row=4, column=3) right_button['command'] = lambda: right_callback(mqtt_client, left_speed, right_speed) root.bind('<Right>', lambda event: right_callback(mqtt_client, left_speed, right_speed)) stop_button = ttk.Button(main_frame, text="Stop") stop_button.grid(row=4, column=2) stop_button['command'] = lambda: stop_callback(mqtt_client) root.bind('<space>', lambda event: stop_callback(mqtt_client)) quit_button = ttk.Button(main_frame, text="Quit") quit_button.grid(row=5, column=5) quit_button['command'] = (lambda: quit_program(mqtt_client, False)) root.bind('<q>', lambda event: quit_program(mqtt_client, False)) park_button = ttk.Button(main_frame, text="Pick up box?") park_button.grid(row=3, column=4) park_button['command'] = lambda: park_callback(mqtt_client) root.bind('<p>', lambda event: park_callback(mqtt_client)) arm_down_button = ttk.Button() arm_down_button['command'] = lambda: arm_down_callback(mqtt_client) root.bind('<d>', lambda event: arm_down_callback(mqtt_client)) cali_button = ttk.Button() cali_button['command'] = lambda: cali_callback(mqtt_client) root.bind('<c>', lambda event: cali_callback(mqtt_client)) e_button = ttk.Button(main_frame, text="Exit") e_button.grid(row=6, column=5) e_button['command'] = (lambda: quit_program(mqtt_client, True)) root.bind('<e>', lambda event: quit_program(mqtt_client, True)) root.mainloop()
def main(): # TO DO: 2. Set my_name and set team_member_name then try this program with that person. # For teams of 3 just have 2 people talk to each other and the other person can just watch this time. my_name = input( "Name of sub.: " ) # Used to set the topic that you are *subscribed to* listen to team_member_name = input( "Team name(pub to): " ) # Used to set the topic that you will *publish to* # What happens if you set my_name and team_member_name to the same value? # The goal is simply for you to become more comfortable with how subscriptions and publish work with MQTT # Review the code to see if there are any other useful things you can learn. # TODO: 3. Call over a TA or instructor to sign your team's checkoff sheet. # # Observations you should make: # You published messages to "legoXX/{team_member_name}" (where XX is set in libs/mqtt_remote_method_calls.py) # You subscribed to messages for "legoXX/{my_name}" # So only MQTT clients listening for that name will hear, and you only hear messages sent to you. # Later you'll publish messages to your EV3 and subscribe to messages that your EV3 sends. root = tkinter.Tk() root.title = "MQTT PyChat" main_frame = ttk.Frame(root, padding=20, relief='raised') main_frame.grid() label = ttk.Label(main_frame, justify=tkinter.LEFT, text="Send a message to " + team_member_name) label.grid(columnspan=2) msg_entry = ttk.Entry(main_frame, width=60) msg_entry.grid(row=2, column=0) msg_button = ttk.Button(main_frame, text="Send") msg_button.grid(row=2, column=1) msg_button['command'] = lambda: send_message(mqtt_client, my_name, chat_window, msg_entry) root.bind( '<Return>', lambda event: send_message(mqtt_client, my_name, chat_window, msg_entry)) chat_window = ttk.Label(main_frame, justify=tkinter.LEFT, text="", width=60, wraplength="500p") # chat_window.pack(fill="x") chat_window.grid(columnspan=2) q_button = ttk.Button(main_frame, text="Quit") q_button.grid(row=4, column=1) q_button['command'] = (lambda: quit_program(mqtt_client)) # Create an MQTT connection my_delegate = MyDelegate(chat_window) mqtt_client = com.MqttClient(my_delegate) mqtt_client.connect(my_name, team_member_name) # mqtt_client.connect(my_name, team_member_name, "35.194.247.175") # Off campus IP address of a GCP broker root.mainloop()
def main(): # Makes a robot for a delegate and then starts a connection robot = robo.Snatch3r() mqtt_client = com.MqttClient(robot) mqtt_client.connect_to_pc() # Initial variable values for calculations and sending robot.right_motor.position = 0 robot.left_motor.position = 0 right_start = 0 left_start = 0 x_start = 250 y_start = 250 angle_total = math.pi # While loop to keep the robot running while not robot.touch_sensor.is_pressed: # Strange if statement formatted by the text editor that sets a # range of area for the robot to stop or beep if not (not (11 < robot.ir_sensor.proximity) or not ( 20 >= robot.ir_sensor.proximity)): # Robot will beep as a warning that the robot is getting close # to something ev3.Sound.beep() time.sleep(1) elif robot.ir_sensor.proximity <= 10: # Stops the robot if the robot is too close to something robot.stop() ev3.Sound.speak('Crash Avoided') time.sleep(5) # Calculation to send map items right = right_start right_new = robot.right_motor.position left = left_start left_new = robot.left_motor.position distance = (right_new - right) / 10 distance_y = (left_new - left) / 10 if (not distance <= 0 and 0 > distance_y) or (not distance >= 0 and 0 < distance_y): angle = ((right_new-right)/5.14)*(math.pi/180) else: angle = 0 angle_total = angle_total + angle # Send command for the computer send_map(mqtt_client, x_start, y_start, angle_total) right_start = right_new left_start = left_new time.sleep(0.01) # r = 30 # theta is found from time that robot turns and speed at which robot # turns # theta start is 0.951 radians # ANGLES FOR MATH NEEDS TO BE IN RADIANS # Need scale factor for distance robot.shutdown()
def main(): # DONE: 2. Setup an mqtt_client. Notice that since you don't need to receive any messages you do NOT need to have # a MyDelegate class. Simply construct the MqttClient with no parameter in the constructor (easy). mqtt_client = com.MqttClient() mqtt_client.connect_to_ev3() root = tkinter.Tk() root.title("MQTT Remote") main_frame = ttk.Frame(root, padding=20, relief='raised') main_frame.grid() enter_emotion_entry = ttk.Entry(main_frame, width=8) enter_emotion_entry.grid(row=5, column=1) enter_emotion_button = ttk.Button(main_frame, text='Enter Emotion Color') enter_emotion_button.grid(row=6, column=1) enter_emotion_button['command'] = lambda: emotion(mqtt_client, enter_emotion_entry) slider_speed_left_label = ttk.Label(main_frame, text="Left Speed") slider_speed_left_label.grid(row=0, column=0) slider_speed_left= tkinter.Scale(main_frame, from_=0, to_=600, orient=tkinter.HORIZONTAL) slider_speed_left.grid(row=1, column=0) slider_speed_right_label = ttk.Label(main_frame, text="Right Speed") slider_speed_right_label.grid(row=0, column=2) slider_speed_right = tkinter.Scale(main_frame, from_=0, to_=600, orient=tkinter.HORIZONTAL) slider_speed_right.grid(row=1, column=2) forward_button = ttk.Button(main_frame, text="Forward") forward_button.grid(row=2, column=1) # forward_button and '<Up>' key is done for your here... forward_button['command'] = lambda: move_forward(mqtt_client, slider_speed_left, slider_speed_right) root.bind('<Up>', lambda event: move_forward(mqtt_client, slider_speed_left, slider_speed_right)) left_button = ttk.Button(main_frame, text="Left") left_button.grid(row=3, column=0) # left_button and '<Left>' key left_button['command'] = lambda: turn_left(mqtt_client, slider_speed_left, slider_speed_right) root.bind('<Left>', lambda event: turn_left(mqtt_client, slider_speed_left, slider_speed_right)) stop_button = ttk.Button(main_frame, text="Stop") stop_button.grid(row=3, column=1) # stop_button and '<space>' key (note, does not need left_speed_entry, right_speed_entry) stop_button['command'] = lambda: stop(mqtt_client) root.bind('<space>', lambda event: stop(mqtt_client)) right_button = ttk.Button(main_frame, text="Right") right_button.grid(row=3, column=2) # right_button and '<Right>' key right_button['command'] = lambda: turn_right(mqtt_client, slider_speed_left, slider_speed_right) root.bind('<Right>', lambda event: turn_right(mqtt_client, slider_speed_left, slider_speed_right)) back_button = ttk.Button(main_frame, text="Back") back_button.grid(row=4, column=1) # back_button and '<Down>' key back_button['command'] = lambda: move_back(mqtt_client, slider_speed_left, slider_speed_right) root.bind('<Down>', lambda event: move_back(mqtt_client, slider_speed_left, slider_speed_right)) up_button = ttk.Button(main_frame, text="Up") up_button.grid(row=5, column=0) up_button['command'] = lambda: send_up(mqtt_client) root.bind('<h>', lambda event: send_up(mqtt_client)) down_button = ttk.Button(main_frame, text="Down") down_button.grid(row=6, column=0) down_button['command'] = lambda: send_down(mqtt_client) root.bind('<j>', lambda event: send_down(mqtt_client)) # Buttons for quit and exit q_button = ttk.Button(main_frame, text="Quit") q_button.grid(row=5, column=2) q_button['command'] = (lambda: quit_program(mqtt_client, False)) e_button = ttk.Button(main_frame, text="Exit") e_button.grid(row=6, column=2) e_button['command'] = (lambda: quit_program(mqtt_client, True)) c_button = ttk.Button(main_frame, text="Crush") c_button.grid(row=7, column=2) c_button['command'] = (lambda: grab(mqtt_client)) root.bind('<c>', lambda event: grab(mqtt_client)) c_button = ttk.Button(main_frame, text="Calibrate") c_button.grid(row=7, column=0) c_button['command'] = (lambda: cali(mqtt_client)) root.bind('<c>', lambda event: cali(mqtt_client)) root.mainloop()
def main(): """ This code, which must run on a LAPTOP: 1. Constructs a GUI for my part of the Capstone Project. 2. Communicates via MQTT with the code that runs on the EV3 robot. """ # ------------------------------------------------------------------------- # Construct and connect the MQTT Client: # ------------------------------------------------------------------------- mqtt_sender = com.MqttClient() mqtt_sender.connect_to_ev3() # ------------------------------------------------------------------------- # The root TK object for the GUI: # ------------------------------------------------------------------------- root = tkinter.Tk() root.title('ZZ Capstone Project') # ------------------------------------------------------------------------- # The main frame, upon which the other frames are placed. # ------------------------------------------------------------------------- main_frame = ttk.Frame(root, padding=10, borderwidth=5, relief="groove") main_frame.grid() # ------------------------------------------------------------------------- # Sub-frames for the shared GUI that the team developed: # ------------------------------------------------------------------------- #teleop_frame, arm_frame, control_frame,drive_system_frame, sound_system_frame=get_shared_frames(main_frame,mqtt_sender) # ------------------------------------------------------------------------- # Frames that are particular to my individual contributions to the project. # ------------------------------------------------------------------------- # TODO: Implement and call get_my_frames(...) #Feature 9 Person 3 #flashy_pickup_frame=ttk.Frame(padding=10,borderwidth=5,relief="groove") #flashy_pickup_button=ttk.Button(flashy_pickup_frame,text="Flashy Pickup") #speed_label=ttk.Label(flashy_pickup_frame, text='Starting Flash Speed') #speed_entry=ttk.Entry(flashy_pickup_frame, width='10') #increase_label=ttk.Label(flashy_pickup_frame, text='Flash Speed Increase') #increase_entry=ttk.Entry(flashy_pickup_frame, width='10') #flashy_pickup_label=ttk.Label(flashy_pickup_frame, text='Flash While Getting an Item') #flashy_pickup_label.grid(row=0, column=1) #flashy_pickup_button.grid(row=1, column=1) #speed_label.grid(row=1, column=0) #speed_entry.grid(row=2,column=0) #increase_label.grid(row=1, column=2) #increase_entry.grid(row=2, column=2) #flashy_pickup_button["command"]=lambda: handle_flashy_pickup(speed_entry,increase_entry,mqtt_sender) # ------------------------------------------------------------------------- # Grid the frames. # ------------------------------------------------------------------------- #grid_frames(teleop_frame,arm_frame,control_frame,drive_system_frame,sound_system_frame,flashy_pickup_frame) #-------------------------------------------------------------------------- #Sprint 3 Stuff (Final Personalized GUI) #-------------------------------------------------------------------------- filename = PhotoImage( file="C:\\Users\\zdanavz\\Documents\\Classes\\CS120\\Jaws.jpg") Jaws_Pic = ttk.Label(main_frame, image=filename) Jaws_Pic.grid() RoboShark_Frame = ttk.Frame(padding=10, borderwidth=5, relief="groove") RoboShark_Label = ttk.Label(RoboShark_Frame, text="ROBOSHARK") Hunt_Button = ttk.Button(RoboShark_Frame, text="HUNT!") Lazer_Beam_Button = ttk.Button(RoboShark_Frame, text="FIRE LAZER!") Action_Label = ttk.Label(RoboShark_Frame, text="Waiting") RoboShark_Frame.grid(row=0, column=1) RoboShark_Label.grid(row=0, column=1) Hunt_Button.grid(row=1, column=1) Lazer_Beam_Button.grid(row=2, column=1) Action_Label.grid(row=3, column=1) Hunt_Button["command"] = lambda: (handle_hunt(mqtt_sender), Action_Label.config(text="Hunting")) Lazer_Beam_Button["command"] = lambda: (handle_Lazer( mqtt_sender), Action_Label.config(text="Lazer Fired")) # ------------------------------------------------------------------------- # The event loop: # ------------------------------------------------------------------------- root.mainloop()
def main(): """Creates a GUI and monitors the state of keyboard buttons to determine robot's motion.""" my_delegate = MyDelegate() mqtt_client = com.MqttClient(my_delegate) mqtt_client.connect_to_ev3() root = Tk() root.title("Mario Kart") main_frame = Frame(root, width=400, height=400) main_frame.pack_propagate(0) main_frame.pack() picture_frame = Frame(main_frame, width=200, height=200, background='white', borderwidth=4, relief=RIDGE) picture_frame.grid(columnspan=2, row=3, column=0) photo1 = PhotoImage(file='blank.gif') photo2 = PhotoImage(file='star_mario.gif') photo3 = PhotoImage(file='mushroom_.gif') photo4 = PhotoImage(file='ink.gif') # photo1 = 'white' # photo2 = 'yellow' # photo3 = 'red' # photo4 = 'black' my_delegate.dc.photos += [photo1, photo2, photo3, photo4] my_delegate.dc.window = Label(picture_frame, image=photo1) forward_button = Button(main_frame, text="Forward = w") forward_button["command"] = lambda: forward_callback(mqtt_client) forward_button.grid(row=0, column=1) root.bind('<w>', lambda event: forward_callback(mqtt_client)) left_button = Button(main_frame, text="Left = a") left_button["command"] = lambda: left_callback(mqtt_client) left_button.grid(row=1, column=0) root.bind('<a>', lambda event: left_callback(mqtt_client)) right_button = Button(main_frame, text="Right = d") right_button["command"] = lambda: right_callback(mqtt_client) right_button.grid(row=1, column=2) root.bind('<d>', lambda event: right_callback(mqtt_client)) stop_button = Button(main_frame, text="Stop = s") stop_button["command"] = lambda: stop_callback(mqtt_client) stop_button.grid(row=1, column=1) root.bind('<s>', lambda event: stop_callback(mqtt_client)) powerup_frame = Frame(main_frame, width=200, height=30, background='yellow', borderwidth=6, relief=RAISED) powerup_frame.grid(columnspan=2, row=2, column=0) powerup_label = Label(powerup_frame, text="Powerup:") powerup_label.grid(row=0, column=0) my_delegate.dc.powerup_label = Label(powerup_frame, text=my_delegate.dc.current_powerup) my_delegate.dc.powerup_label.grid(row=0, column=1) use_powerup = Button(main_frame, text="Use Powerup = Space") use_powerup['command'] = lambda: powerup_callback(mqtt_client, my_delegate) use_powerup.grid(row=1, column=3) root.bind('<space>', lambda event: powerup_callback(mqtt_client, my_delegate)) quit_button = Button(main_frame, text="Quit") quit_button['command'] = lambda: quit_program(mqtt_client) quit_button.grid(row=3, column=3) root.bind('<q>', lambda event: quit_program(mqtt_client)) root.bind('<KeyRelease-w>', lambda event: stop_callback(mqtt_client)) root.bind('<KeyRelease-a>', lambda event: stop_callback(mqtt_client)) root.bind('<KeyRelease-d>', lambda event: stop_callback(mqtt_client)) root.mainloop()
def main(): """Allows for the robot to connect to the computer and recieve commands""" robot = robo.Snatch3r() mqtt_client = com.MqttClient(robot) mqtt_client.connect_to_pc() robot.loop_forever()
def main(): mqtt_client = com.MqttClient() mqtt_client.connect_to_ev3() root = tkinter.Tk() root.title("MQTT Remote") main_frame = ttk.Frame(root, padding=20, relief='raised') main_frame.grid() green_button = ttk.Button(main_frame, text="Find Green") green_button.grid(row=0, column=0) green_button['command'] = lambda: find_color(mqtt_client, "SIG1") blue_button = ttk.Button(main_frame, text="Find Blue") blue_button.grid(row=1, column=0) blue_button['command'] = lambda: find_color(mqtt_client, "SIG2") pink_button = ttk.Button(main_frame, text="Find Pink") pink_button.grid(row=0, column=1) pink_button['command'] = lambda: find_color(mqtt_client, "SIG3") yellow_button = ttk.Button( main_frame, text="Find Yellow", ) yellow_button.grid(row=1, column=1) yellow_button['command'] = lambda: find_color(mqtt_client, "SIG4") q_button = ttk.Button(main_frame, text="Exit") q_button.grid(row=14, column=2) q_button['command'] = (lambda: quit_program(mqtt_client, False)) left_speed_label = ttk.Label(main_frame, text="Left") left_speed_label.grid(row=8, column=0) left_speed_entry = ttk.Entry(main_frame, width=8) left_speed_entry.insert(0, "600") left_speed_entry.grid(row=9, column=0) right_speed_label = ttk.Label(main_frame, text="Right") right_speed_label.grid(row=8, column=2) right_speed_entry = ttk.Entry(main_frame, width=8, justify=tkinter.RIGHT) right_speed_entry.insert(0, "600") right_speed_entry.grid(row=9, column=2) forward_button = ttk.Button(main_frame, text="Forward") forward_button.grid(row=10, column=1) # forward_button and '<Up>' key is done for your here... forward_button['command'] = lambda: handle_forward_button( mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Up>', lambda event: handle_forward_button( mqtt_client, left_speed_entry, right_speed_entry)) left_button = ttk.Button(main_frame, text="Left") left_button.grid(row=11, column=0) left_button['command'] = lambda: handle_left_button( mqtt_client, right_speed_entry) root.bind('<Left>', lambda event: handle_left_button(mqtt_client, right_speed_entry)) # left_button and '<Left>' key right_button = ttk.Button(main_frame, text="Right") right_button.grid(row=11, column=2) right_button['command'] = lambda: handle_right_button( mqtt_client, left_speed_entry) root.bind('<Right>', lambda event: handle_right_button(mqtt_client, left_speed_entry)) # right_button and '<Right>' key back_button = ttk.Button(main_frame, text="Back") back_button.grid(row=12, column=1) back_button['command'] = lambda: handle_back_button( mqtt_client, left_speed_entry, right_speed_entry) root.bind( '<Down>', lambda event: handle_back_button( mqtt_client, left_speed_entry, right_speed_entry)) # back_button and '<Down>' key up_button = ttk.Button(main_frame, text="Up") up_button.grid(row=0, column=2) up_button['command'] = lambda: send_up(mqtt_client) root.bind('<u>', lambda event: send_up(mqtt_client)) down_button = ttk.Button(main_frame, text="Down") down_button.grid(row=1, column=2) down_button['command'] = lambda: send_down(mqtt_client) root.bind('<j>', lambda event: send_down(mqtt_client)) stop_button = ttk.Button(main_frame, text="Stop") stop_button.grid(row=11, column=1) left_button['command'] = lambda: handle_stop(mqtt_client) root.bind('<space>', lambda event: handle_stop(mqtt_client)) # stop_button and '<space>' key (note, does not need left_speed_entry, right_speed_entry) root.mainloop()