Índice:

• Introducción
• Organización y Planificación
• Progreso del Robot
• Análisis - Diseño
• Código Utilizado
• Resultados

Código Utilizado¶

Servidor

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

Funciones del Robot

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

Interfaz Gráfica

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