Proyecto 1 2024 » Grupo 2 B

h1. Código Utilizado

*Servidor*

<pre><code class="python">

import socket

from main import *

server = socket.socket()

PORT = 8080

server.bind(('', PORT))

server.listen(1)

connection, adress = server.accept()

actions = {

    "w" : move_front,

    "a" : move_left,

    "d" : move_right,

    "s" : move_back,

    "e" : move_grab,

    "r" : move_release,

}

while True:

    data = connection.recv(1)

    keyword = data.decode("utf-8")

    if keyword in actions:

        actions[keyword]()

    elif keyword == "q":

        break

</code></pre>

*Funciones*

<pre><code class="python">

#!/usr/bin/env pybricks-micropython

from pybricks.hubs import EV3Brick

from pybricks.ev3devices import Motor

from pybricks.parameters import Port, Stop, Direction, Button, Color

from pybricks.tools import wait, StopWatch, DataLog

from pybricks.robotics import DriveBase

from pybricks.media.ev3dev import SoundFile, ImageFile

#Initialize the EV3 brick.

ev3 = EV3Brick()

motor_right = Motor(Port.A, Direction.COUNTERCLOCKWISE)

motor_left = Motor(Port.D, Direction.COUNTERCLOCKWISE)

motor_garra= Motor(Port.B)

robot = DriveBase(motor_left,motor_right, wheel_diameter=55.5, axle_track=84)

robot.settings(600, 500, 1000, 500)

def move_front():

        robot.straight(150)

def move_back():

        robot.straight(-150)

def move_right():

        robot.turn(300)

def move_left():

        robot.turn(-300)

def move_grab():

    motor_garra.run_until_stalled(-300, Stop.HOLD, 40)

def move_release():

    motor_garra.run_until_stalled(300, Stop.COAST, 40)

# Detener el robot

robot.stop()

ev3.speaker.beep()

</code></pre>

*Interfaz Gráfica*

<pre><code class="python">

import tkinter as tk

from tkinter import ttk

from tkinter import messagebox

import socket

class App(tk.Tk):

    STATUS_CONNECTION = False

    PORT = 8080

    def __init__(self):

        super().__init__()

        self.title("Ball-e")

        self.config(padx=10, pady=10, bg="#FFC0CB")

        self.geometry("800x600")

        self.canvas = tk.Canvas(self, width=800, height=600)

        self.canvas.pack()

        self.resizable(width=False, height=False)

        self.imagen_fondo = tk.PhotoImage(file="fondo.png")

        self.imagen_fondo = self.imagen_fondo.subsample(5,5)

        self.canvas.create_image(0, 0, anchor=tk.NW, image=self.imagen_fondo)

        self.init_images()

        self.init_elements()

        self.grab_open = True  # Inicialmente, la garra está abierta

    def init_images(self):

        imagenes = ["encendido.png"]

        self.images = [tk.PhotoImage(file=imagen).subsample(12, 12) for imagen in imagenes]

        self.garra_abierta_img = tk.PhotoImage(file="garra_abierta.png").subsample(10, 10)  

        self.garra_cerrada_img = tk.PhotoImage(file="garra_cerrada.png").subsample(10, 10)

        imagenes1 = ["flechaFront.png", "flechaBack.png", "flechaLeft.png", "flechaRight.png"]

        self.images1 = [tk.PhotoImage(file=imagen).subsample(25, 25) for imagen in imagenes1]

        self.flechaFront, self.flechaBack, self.flechaLeft, self.flechaRight= self.images1

    def init_elements(self):

        btn_color = "#fff" if self.STATUS_CONNECTION else "#000" 

        self.btn_Connect = tk.Button(self, bd=0, bg=btn_color, width=40, height=40, command=self.ip_connect).place(x=710, y=500)

        self.btn_Front = tk.Button(self, image= self.flechaFront, bd=0, bg="white", highlightbackground='white', width=80, height=80, command=lambda: self.move_front_car(None)).place(x=545,y=100)

        self.btn_Back = tk.Button(self, image= self.flechaBack, bd=0, width=80, height=80, command=lambda:self.move_back_car(None)).place(x=545,y=300)

        self.btn_Left = tk.Button(self, image= self.flechaLeft, bd=0, width=80, height=80, command=lambda:self.move_left_car(None)).place(x=450,y=200)

        self.btn_Right = tk.Button(self, image= self.flechaRight, bd=0, width=80, height=80, command=lambda: self.move_right_car(None)).place(x=640,y=200)

        self.btn_Grab = tk.Button(self, image=self.garra_abierta_img, bd=0, command=lambda: self.move_grab_car(None)).place(x=545, y=200)

    def ip_connect(self):

        if not self.STATUS_CONNECTION:

            self.ventana_conexion = tk.Toplevel(self)

            self.ventana_conexion.title("Ventana de Conexión")

            self.ventana_conexion.geometry("200x150")

            self.ventana_conexion.resizable(width=False, height=False)

            etiqueta = tk.Label(self.ventana_conexion, text="Ingrese la dirección IP:")

            etiqueta.pack(pady=10)

            self.IP = tk.StringVar()

            entry_ip = tk.Entry(self.ventana_conexion, textvariable=self.IP)

            entry_ip.pack(pady=10)

            btn_conectar = tk.Button(self.ventana_conexion, text="Conectar", command= lambda: self.robot_connection(self.IP.get()))

            btn_conectar.pack(pady=10)

        else:

            self.robot_connection(self.IP.get())

    def robot_connection(self, IP):

        if self.STATUS_CONNECTION:

            self.STATUS_CONNECTION = not self.STATUS_CONNECTION

            self.init_elements()  

        else:

            try:

                self.client = socket.socket()

                self.client.connect((IP, self.PORT))  

                self.STATUS_CONNECTION = True

                self.init_elements()

                messagebox.showinfo("Conexión exitosa", "Se ha conectado al robot correctamente.")  

                self.ventana_conexion.destroy()

            except socket.error:

                messagebox.showerror("Error", "No se pudo conectar al robot.")

                self.STATUS_CONNECTION = False

    def move_front_car(self, event):

        self.client.send(bytes([ord('w')]))

    def move_left_car(self, event):

        self.client.send(bytes([ord('a')]))

    def move_right_car(self, event):

        self.client.send(bytes([ord('d')]))

    def move_back_car(self, event):

        self.client.send(bytes([ord('s')]))

    def move_grab_car(self, event):

        self.client.send(bytes([ord('e')])) 

        if self.grab_open:

            self.grab_open = False  # Ahora la garra está cerrada

            self.btn_Grab.config(image=self.garra_cerrada_img)

        else:

            self.grab_open = True  # Ahora la garra está abierta

            self.btn_Grab.config(image=self.garra_abierta_img)

if __name__ == "__main__":

    app = App()

    app.mainloop()

</code></pre>