PROYECTO 1 2023 » GRUPO 1 A 2023

h2. *Índice*: 

* [[Introducción]]

* [[Organización y Planificación]]

* [[Progreso del Robot]]

* [[Análisis - Diseño]]

* [[Código Utilizado]]

* [[Resultados]]

h1. Código Utilizado

*+Servidor+*

<pre>

import socket

from robot import robot

server = socket.socket()

PORT = 8800

server.bind(('', PORT))

server.listen(1)

connection, adress = server.accept()

robot = Robot()[[]]

actions = {

    "w" : robot.move_front,

    "a" : robot.move_left,

    "d" : robot.move_right,

    "s" : robot.move_back,

    "e" : robot.move_punch,

}

while True:

    data = connection.recv(1)

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

    if keyword in actions:

        actions[keyword]()

    elif keyword == "q":

        break

</pre>

*+Funciones del Robot+*

<pre>

from ev3dev2.motor import (LargeMotor, MoveTank, MediumMotor, OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D)

from time import sleep

class Robot:

    eje = 0

    base = -0.58

    MAX_VALUE_EJE = 140

    MIN_VALUE_EJE = -140

    MAX_VALUE_BASE = 0

    MIN_VALUE_BASE = -0.58

    SPEED = 100

    contaux1 = 0

    contaux2 = 0

    cont = 1

    def __init__(self):

        self.out_a = LargeMotor(OUTPUT_A) # movimiento pelota

        self.out_b = LargeMotor(OUTPUT_B) # ruedas de atras, movimiento

        self.out_c = MediumMotor(OUTPUT_C) # ruedas de rotacion, giro izquierda/derecha

        self.out_d = MediumMotor(OUTPUT_D) # lanzamiento de pelota

    # Función para desactivar completamente el robot

    def off_robot(self):

        self.out_a.stop()

        self.out_b.stop()

        self.out_c.stop()

        self.out_d.stop()

    # Función para mover el robot hacia adelante 

    def move_front(self):

        self.out_b.on_for_rotations(speed = 100, rotations= -2, brake = True, block = True)

        self.out_b.stop()

    # Función para mover el robot hacia atras

    def move_back(self):

        self.out_b.on_for_rotations(speed = 100, rotations= 2, brake = True, block = True)

        self.out_b.stop()

    # Función para mover las ruedas del robot hacia la derecha

    def move_right(self):

        if(self.MIN_VALUE_EJE < self.eje): # Se comprueba el eje de las ruedas para no provocar una falla en el robot / para que no se queden pegadas

            self.out_c.on_for_degrees(speed = 100, degrees = -1.4, brake = True, block = True)

            self.eje-=1.4

            self.contaux1-=1

        print(self.eje)

        self.out_c.stop()

    # Función para mover las ruedas del robot hacia la izquierda

    def move_left(self):

        if(self.MAX_VALUE_EJE > self.eje): # Se comprueba el eje de las ruedas para no provocar una falla en el robot / para que no se queden pegadas

            self.out_c.on_for_degrees(speed = 100, degrees = 1.4, brake = True, block = True)

            self.eje+=1.4

            self.contaux2+=1

        print(self.eje)

        self.out_c.stop()

    # Función para ingresar los grados para hacer el golpe

    def move_punch(self, vel, grad):  

        self.vel = vel

        self.grad = grad

        self.out_d.on_for_degrees(speed = 100, degrees=grad)

        self.out_d.stop()

    # Función para mover la base de la pelota, hacia adelante

    def mov_adel(self):

        if(self.MAX_VALUE_BASE>self.base): # Se comprueba la base de la pelota para que no falle el robot / en este caso para que no se golpee hacia atras

            self.out_a.on_for_rotations(speed = 100, rotations=-0.0116, brake = True, block = True)

            self.base += 0.0116

        self.out_a.stop()

    # Función para mover la base de la pelota, hacia atras

    def mov_atras(self):

        if(self.MIN_VALUE_BASE<self.base): # Se comprueba la base de la pelota para que no falle el robot / en este caso es para que no se pase hacia adelante

            self.out_a.on_for_rotations(speed = 100, rotations=0.0116, brake = True, block = True)

            self.base -= 0.0116

        self.out_a.stop()

    def off(self):

        if(self.base>-0.58):  # Se comprueba si esta en la posicion original la base de la pelota

            while(True):

                if(50 == self.cont):

                    return False # Se rompe el ciclo solo si la base tiene 4, donde estara en posicion original

                else:

                    self.out_a.on_for_rotations(speed = 100, rotations = 0.0116, brake = True, block = True)

                    self.base+=0.0116

                    self.cont = self.cont + 1

                    print(self.cont)

                    self.out_a.stop()

</pre>

*+Interfaz Gráfica+*

<pre python>

import tkinter as tk

from tkinter import ttk

import socket

class App(tk.Tk):

    STATUS_CONNECTION = False

    PORT = 8800

    def __init__(self):

        super().__init__()

        self.title("Princesita")

        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()

    def init_images(self):

        imagenes = ["encendido.png", "deslizador.png"]

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

        self.connect, self.deslizador= self.images

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

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

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

    def init_elements(self):   

        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_Punch = tk.Button(

                self,

                image=self.punteria,

                bd=0,

                width=80,

                height=80,

                command= lambda : self.move_punch(None)

        ).place(x=545,y=200)

        self.btn_Connect = tk.Button(

                self,

                image=self.connect,

                bd= 0,

                bg= "#fff" if self.STATUS_CONNECTION  else "#000",

                width=40,

                height=40,

                command=self.ip_connect

        ).place(x=710,y=500)

        self.label_deslizador = tk.Label(

                self,

                image=self.deslizador,

                bd=0,

                bg= "#bcdc8c",

                highlightthickness=0,

                width=60,

                height=40,

        )

        self.label_deslizador.place(x=90, y=500)

        self.distancia = tk.DoubleVar()

        style = ttk.Style()

        style.configure("TScale", troughcolor="#bcdc8c",background="#bcdc8c", sliderthickness=20)

        def update_image_position(event):

                value = self.Scala.get()

                x_position = self.Scala.winfo_x() + value * self.Scala.winfo_width() / self.Scala.cget("to")

                self.label_deslizador.place(x= 85 + self.Scala.get() * 3, y=490)

        self.Scala = ttk.Scale(

            self,

            orient = "horizontal",

            from_=1, to=50,

            style="TScale",

            length=200

        )

        self.Scala.place(x=90, y=540)

        self.Scala.bind("<Motion>", update_image_position)

        update_image_position(None)

    def ip_connect(self):

        if self.STATUS_CONNECTION == False:

            ventana_conexion = tk.Toplevel(self)

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

            ventana_conexion.geometry("200x150")

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

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

            etiqueta.pack(pady=10)

            self.IP = tk.StringVar()

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

            entry_ip.pack(pady=10)

            btn_conectar = tk.Button(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_images()

            self.init_elements()

        else:

            try:

                self.client = socket.socket()

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

                self.STATUS_CONNECTION = True

            except socket.error:

                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_punch(self, event):

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

if __name__ == "__main__":

    app = App()

    app.mainloop()

</pre>