Project

General

Profile

Código Utilizado » History » Version 9

Version 8 (Melisa Laura, 12/21/2023 04:17 PM) → Version 9/10 (Cristian Huanca, 01/05/2024 12:34 AM)

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()
&lt;pre&gt;

</pre>