diff --git a/00_las_luces.py b/00_las_luces.py new file mode 100644 index 0000000..24ec80f --- /dev/null +++ b/00_las_luces.py @@ -0,0 +1,50 @@ +from taller_programacion import * + +""" +Vamos a encender unas cuentas luces +""" +imprimir(luces) # Imprimimos la descripción de las luces +luces.borrar() # Borramos si hay algo pintado de antes +luces.pintarLed(numero_de_led=1, color="rojo") # El primer led lo pintamos de rojo +luces.pintarLed(2, "verde") # El segundo lo pintamos verde, esta vez nos ahorramos escribir numero_de_led y color +luces.pintarLed(3, "azul") # El tercer led será azul +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s +""" Moveremos a la derecha 4 veces """ +luces.moverDerecha() # Movemos las luces a la derecha 1 posición +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s + +luces.moverDerecha() # Movemos las luces a la derecha 1 posición +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s + +luces.moverDerecha() # Movemos las luces a la derecha 1 posición +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s + +luces.moverDerecha() # Movemos las luces a la derecha 1 posición +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s + +""" Pintamos un arcoiris """ +""" Moveremos a la derecha 4 veces """ +luces.pintarArcoiris() # Pintamos un arcoiris +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s + +luces.moverDerecha() # Movemos las luces a la derecha 1 posición +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s + +luces.moverDerecha() # Movemos las luces a la derecha 1 posición +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s + +luces.moverDerecha() # Movemos las luces a la derecha 1 posición +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s + +luces.moverDerecha() # Movemos las luces a la derecha 1 posición +luces.iluminar() # Iluminamos para que se enciendan las luces +dormir(1) # Esperamos 1s diff --git a/00_los_mandos.py b/00_los_mandos.py new file mode 100644 index 0000000..2ee40fc --- /dev/null +++ b/00_los_mandos.py @@ -0,0 +1,10 @@ +from taller_programacion import * + +""" +Vamos a probar los mandos +""" +mandos.imprimirBotones("SI") # Con esta instrucción saldrá un mensaje por consola cada vez que se apriete un botón +mandos.imprimirPasos("SI") # Con esta instrucción saldrá un mensaje por consola cada vez que se gire el mando + +imprimir(mandos) # Imprimimos la descripción de los mandos +dormir(10) # Mientras esta el programa esperando podremos ver los mensajes por consola al usar los mandos diff --git a/01_hacer_comentarios.py b/01_hacer_comentarios.py new file mode 100644 index 0000000..946f38d --- /dev/null +++ b/01_hacer_comentarios.py @@ -0,0 +1,36 @@ +from taller_programacion import * +""" +Cuando necesitamos escribir algo para nosotros +como una nota o un comentario +pero que el programa no de error porque no entiende lo que hemos escrito +podemos hacerlo de dos maneras diferentes: +""" + +""" Una es usar la triple comilla y nuestro mensaje dentro """ + +# La otra es usar el corchete antes de escribir + +""" La diferencia entre las dos es que con la triple comilla podemos +hacer varias líneas +sin preocuparnos en nada +pero es importante cerrar siempre las comillas +""" + +# Si usamos el corchete debemos colocarlo siempre antes del comentario +# y en cada línea +# para que no de error + + +""" +Prueba a escribir aquí debajo algún comentario como hemos explicado y también sin usar las comillas +o el corchete para ver si da o no error el programa +""" + + + + + + +""" Ahora voy a poner un comentario a una línea de código, esto nos permite poder comentarla para saber lo que hace """ + +imprimir("HOLA! Soy un mensaje que saldrá en la consola de aquí abajo") # Esta instrucción imprimirá por la consola un mensaje \ No newline at end of file diff --git a/02_variables.py b/02_variables.py new file mode 100644 index 0000000..c74b1bf --- /dev/null +++ b/02_variables.py @@ -0,0 +1,62 @@ +from taller_programacion import * +""" +Las variables son como cajas donde guardamos cosas + +Esas cosas pueden ser números, colores, letras, frases, listas de cosas etc... + +La manera de poder usarlas es la siguiente: + · Primero debemos darle un nombre... por ejemplo la llamaremos "caja" + ·Al crearla debemos decirle que contiene, puede ser cualquier cosa de las que hemos comentado antes + la manera de hacerlo es usando el igual. Esta vez haremos que la caja contenga un número. +""" +caja = 10 # Ahora la caja contiene el número 10 + +""" +Para poder ver el contenido de una caja podemos imprimirla por consola así: +""" + +imprimir(caja) # Mostramos por consola el valor de caja + +""" +Siempre podemos volver a darle otro valor a caja, solo debemos dárselo como antes +""" +caja = 22 # Ahora la caja contiene el número 22 + +""" +Vamos a ver si el valor ha cambiado... +""" + +imprimir(caja) # Mostramos por consola el valor de caja + +""" +Puede ser caja otra cosa que no sea un número? Claro! +Dejo aquí abajo diferentes tipos de variables que podemos dale a caja +Prueba tú algunas!! +""" + +caja = "a" # Recuerda que las letras o las frases deben estar siempre entre comillas para decirle al programa que son letras o frases +imprimir(caja) # Mostramos por consola el valor de caja + +caja = "HOLA SOY UNA FRASE" # Recuerda que las letras o las frases deben estar siempre entre comillas para decirle al programa que son letras o frases +imprimir(caja) # Mostramos por consola el valor de caja + +caja = cierto # caja ahora contiene el valor de "cierto" +imprimir(caja) # Mostramos por consola el valor de caja + +caja = falso # caja ahora contiene el valor de "falso" +imprimir(caja) # Mostramos por consola el valor de caja + +caja = 0.1 # caja ahora contiene un valor decimal +imprimir(caja) # Mostramos por consola el valor de caja + +caja = [0,1,2,3,4,5] # caja ahora contiene una lista de números +imprimir(caja) # Mostramos por consola el valor de caja + +caja = ["manzana", "rojo", "arbol"] # caja ahora contiene una lista de palabras +imprimir(caja) # Mostramos por consola el valor de caja + + +""" +Ahora crea una variable con el nombre que tu quieras, dale un valor e imprimela! +""" + diff --git a/02_variables_practica.py b/02_variables_practica.py new file mode 100644 index 0000000..631577c --- /dev/null +++ b/02_variables_practica.py @@ -0,0 +1,22 @@ +from taller_programacion import * + +""" +Vamos a probar a guardar algunos datos en variables +""" + +numero_de_leds = luces.cantidad_de_leds # Guardamos el numero de leds que tenemos + +imprimir("La tira de leds tiene:") # Imprimimos en consola una frase con el numero de leds que tenemos +imprimir(numero_de_leds) +imprimir("leds") + +imprimir("Mover los mandos ahora") # Informamos de que se muevan los mandos +dormir(5) # Esperamos para mover los mandos de mientras + +posicion_mando1 = mandos.posiciones_mando1 # Nos guardamos la posición de los mandos +posicion_mando2 = mandos.posiciones_mando2 + +imprimir("El mando 1 ha girado y está en la posición:") # Imprimimos las posiciones de los dos mandos +imprimir(posicion_mando1) +imprimir("El mando 2 ha girado y está en la posición:") +imprimir(posicion_mando2) \ No newline at end of file diff --git a/03_operaciones.py b/03_operaciones.py new file mode 100644 index 0000000..829f21f --- /dev/null +++ b/03_operaciones.py @@ -0,0 +1,46 @@ +from taller_programacion import * +""" +Podemos hacer operaciones con números, sumar, restar, multiplicar, dividir... +""" +imprimir("Sumamos 2+2:") # Mostramos el mensaje de lo que vamos a hacer +imprimir(2+2) # Las operaciones las podemos hacer directamente antes de imprimir, aquí primero hace la suma y luego imprime + +imprimir("Restamos 2-2:") # Mostramos el mensaje de lo que vamos a hacer +imprimir(2-2) # Podemos restar... + +imprimir("Multiplicamos 2*2:") # Mostramos el mensaje de lo que vamos a hacer +imprimir(2*2) # Podemos multiplicar... + +imprimir("Dividimos 2/2:") # Mostramos el mensaje de lo que vamos a hacer +imprimir(2/2) # Y podemos dividir + +""" +Si colocamos los numeros en variables podemos hacer lo mismo pero usando las variables +""" + +caja1 = 5 # Caja1 tiene el valor 5 +imprimir("caja1 tiene el valor:") # Mostramos el mensaje de lo que contiene caja1 +imprimir(caja1) # Imprimimos el valor de caja1 + +caja2 = 10 # Caja2 tiene el valor 10 +imprimir("caja2 tiene el valor:") # Mostramos el mensaje de lo que contiene caja1 +imprimir(caja2) # Imprimimos el valor de caja2 + +imprimir("Sumamos caja1+caja2:") # Mostramos el mensaje de lo que vamos a hacer +imprimir(caja1+caja2) # Imprimimos el valor de caja1+caja2 que es 5 + 10 = 15 + + +""" +Para acabar podemos guardar el valor de una operación en una nueva variable para tenerlo guardado +""" +imprimir("Guardamos el valor de la suma de caja1+caja2 en caja3") # Mostramos el mensaje de lo que vamos a hacer +caja3 = caja1 + caja2 +imprimir("caja3 tiene el valor:") # Mostramos el mensaje de lo que vamos a hacer +imprimir(caja3) # Imprimimos el valor de caja1+caja2 que es 5 + 10 = 15 + + +""" +Prueba a hacer una operación e imprimirla por pantalla! +""" + + diff --git a/03_operaciones_practica.py b/03_operaciones_practica.py new file mode 100644 index 0000000..694be07 --- /dev/null +++ b/03_operaciones_practica.py @@ -0,0 +1,22 @@ +from taller_programacion import * +""" +Vamos a sumar las posiciones que se mueven los dos mandos durante 5 segundos +""" + +imprimir("Tienes 5 segundos para mover los mandos, YA!") # Escribimos el mensaje en la consola para que se empiecen a mover los mandos + +dormir(5) # Esperamos durante 5 segundos a que se mueven los mandos + +posicion_mando1 = mandos.posiciones_mando1 # Nos guardamos la posición de los mandos +posicion_mando2 = mandos.posiciones_mando2 + +posiciones_totales = posicion_mando1 + posicion_mando2 + +imprimir("Los mandos se han movido") # Imprimimos las posiciones de los dos mandos +imprimir(posiciones_totales) +imprimir("posiciones") + + + + + diff --git a/04_condiciones.py b/04_condiciones.py new file mode 100644 index 0000000..97bf983 --- /dev/null +++ b/04_condiciones.py @@ -0,0 +1,123 @@ +from taller_programacion import * +""" +Las condiciones nos permiten tomar decisiones en el programa, pero qué son las condiciones? + +Ejemplo: + Si me traes el azucar haré un bizcocho. + La condición es que traigas el azucar para hacer el bizcocho, si lo resumimos podemos decir + que si SI hay azucar SI hay bizcocho si NO hay azucar NO hay bizcocho. + Si lo escribimos de otra forma... + si azucar.. + SI -> bizcocho + NO -> pasar hambre +Otro ejemplo: + Si NO fregas los platos hoy duermes en el sofá. + Resumiendo si SI friegas los platos duermes en la cama + si NO friegas los platos duermes en el sofá + Si lo escribimos de otra forma... + si fregar.. + SI -> cama + NO -> sofá +""" + +""" +Las condiciones siempre dependen de algo que se puede simplificar a si es "cierto" o es "falso" y la palabra mágica que define una condición es... +"si" + +si pasas, estás dentro +si saltas, vuelas +si duermes, descansas +si juegas, te diviertes + +""" + + +""" +en programación ese "si" se traduce en "if" y se escribe de esta forma: + if condicion: + lo que pasa si es cierto + +Es importante ver que lo que pasa está mas a la derecha de el "if" y es necesario que sea así y usando un golpe de tabulador. +Explicarlo es enrevesado, es más fácil hacerlo ya verás: +""" + +if cierto: # Si la condición se cumple imprimirá el mensaje. Esta condición siempre se cumplirá pues siempre es cierta + imprimir("Es cierto") + +if falso: # Si la condición se cumple imprimirá el mensaje. Esta condición NUNCA se cumplirá pues siempre es falsa + imprimir("Es falso") + +""" +El ejemplo anterior es muy simple pero un poco antiintuitivo, vamos con algo mas real! +Crearemos una variable y le daremos un valor, luego dependiendo de ese valor cumplirá o no alguna condición +""" + +caja1 = 5 + +if caja1 == 5: # Usamos el doble == porque estamos comparando caja1 con el valor 5, si es igual se imprimirá el mensaje sino no + imprimir("caja1 es igual a 5") + +if caja1 == 6: # Usamos el doble == porque estamos comparando caja1 con el valor 6, si es igual se imprimirá el mensaje sino no + imprimir("caja1 es igual a 6") + + +""" +Qué pasa cuando no se cumple la condición y queremos saberlo? pues podemos usar el "sino" +"si" como, me quedo a gusto, "sino", tengo hambre. +el "sino" en programación se traduce en "else" y se escribe así + +if condicion: + lo que pasa si es cierto +else: + lo que pasa si es falso + +Vamos con un ejemplo práctico: +""" + +if caja1 == 8: # Si la caja1 = 8 se imprimirá el primer mensaje + imprimir("caja1 es igual a 8") +else: # Si la caja NO es igual a 8 se imprimirá el siguiente mensaje + imprimir("caja1 NO es igual a 8") + + +""" +Qué mas tipos de condiciones se pueden hacer? +Pues vamos con unos ejemplos! +""" + +if caja1 > 3: # Es caja1 MAYOR que 3? + imprimir("caja1 MAYOR que 3") +else: + imprimir("caja1 NO es MAYOR que 3") + + + +if caja1 < 10: # Es caja1 MENOR que 10? + imprimir("caja1 es MENOR que 10") +else: + imprimir("caja1 NO es MENOR que 10") + +if caja1 != 10: # Es caja1 es diferente a 10? + imprimir("caja1 es DIFERENTE a 10") +else: + imprimir("caja1 es IGUAL a 10") + + +caja2 = "bocadillo" # Creamos una variable que contiene la palabra bocadillo + +if caja2 == "bocadillo": # Contiene la caja2 la palabra bocadillo? + imprimir("caja2 contiene la palabra bocadillo") +else: + imprimir("caja2 NO contiene la palabra bocadillo") + +""" +Las condiciones que se pueden usar son: +== Para igualar +< Para decir que es menor +> Para decir que es mayor +¡= Para decir que es diferente +>= Para decir que es mayor o igual +<= Para decir que es menor o igual + +""" + diff --git a/04_condiciones_practica.py b/04_condiciones_practica.py new file mode 100644 index 0000000..77667bd --- /dev/null +++ b/04_condiciones_practica.py @@ -0,0 +1,59 @@ +from taller_programacion import * + +""" +Pongamos en práctica unas cuantas condiciones!! +""" + +imprimir("Tienes 5 segundos para pulsar cualquier botón") # Mostramos un mensaje para que se pulse un botón +dormir(5) # Esperamos a que se pulsen los botones + +if mandos.boton1Pulsado(): # si el boton 1 se ha pulsado... + imprimir("El botón 1 se ha pulsado") # Entonces imprimimos este mensaje + +if mandos.boton2Pulsado(): # si el boton 2 se ha pulsado... + imprimir("El botón 2 se ha pulsado") # Entonces imprimimos este mensaje + + +""" +Ahora jugamos girando los mandos +""" + +imprimir("Tienes 5 segundos para girar los mandos") # Mostramos un mensaje para que se pulse un botón +dormir(5) # Esperamos a que se pulsen los botones + +valor_mando1 = mandos.posiciones_mando1 # Guardamos el valor de las posiciones que se ha movido el mando +valor_mando2 = mandos.posiciones_mando2 # Guardamos el valor de las posiciones que se ha movido el mando + +if valor_mando1 != 0: # si el mando1 se ha movido + imprimir("El mando 1 se ha movido:") # Entonces imprimimos este mensaje + imprimir(valor_mando1) +if valor_mando2 != 0: # si el mando1 se ha movido + imprimir("El mando 2 se ha movido:") # Entonces imprimimos este mensaje + imprimir(valor_mando2) + + + +""" +Encendemos unas luces dependiendo de cuanto se ha movido un mando? +""" + +imprimir("Tienes 5 segundos para girar los mandos y encender unas luces") # Mostramos un mensaje para que se pulse un botón +dormir(5) # Esperamos a que se pulsen los botones + +valor_mando1 = mandos.posiciones_mando1 # Guardamos el valor de las posiciones que se ha movido el mando +valor_mando2 = mandos.posiciones_mando2 # Guardamos el valor de las posiciones que se ha movido el mando + +if valor_mando1 > 0: # si el mando1 se ha movido en sentido horario + imprimir("El mando 1 enciende el led número:") # imprimimos un mensaje + imprimir(valor_mando1) # imprimimos el valor de los pasos que ha dado + luces.pintarLed(numero_de_led=valor_mando1, color="rojo") # pintamos el numero de led que coincida con los pasos que se han dado + luces.iluminar() # iluminamos los leds + +if valor_mando2 > 0: # si el mando2 se ha movido en sentido horario + imprimir("El mando 2 enciende el led número:") # imprimimos un mensaje + imprimir(valor_mando2) # imprimimos el valor de los pasos que ha dado + luces.pintarLed(numero_de_led=valor_mando2, color="verde") # pintamos el numero de led que coincida con los pasos que se han dado + luces.iluminar() # iluminamos los leds + + + diff --git a/05_bucles_infinitos.py b/05_bucles_infinitos.py new file mode 100644 index 0000000..f975d8a --- /dev/null +++ b/05_bucles_infinitos.py @@ -0,0 +1,40 @@ +from taller_programacion import * +""" +Los bucles infinitos nos permiten repetir unas instrucciones de manera infinita +o hasta que se cumpla una condición. +Pero que es esto de un bucle?... +Ejemplo: + Mientras juegas fuera de casa tienes que llevar la chaqueta. + Si estás fuera de casa siempre llevarás la chaqueta. +Otro ejemplo: + Mientras la estufa esté encendida estaremos calentitos. + Siempre que la estufa esté encendida no tendremos frío. + +La palabra clave aquí es "mientras", en programación se traduce como while y se escribe así: + +while condicion: + hacemos esto + y esto + y esto + y mas de esto + +Vamos a hacer un ejemplo real. + +""" + +while cierto: # Mientras se cumpla la condición se repetira todo el rato lo que hay escrito en el + imprimir("Me repito") # Imprimimos un mensaje cada vez que se repite el bucle + dormir(1) # Esperamos 1 segundo entre repeticiones + + + +""" +Otro ejemplo, antes de seguir hay que comentar con comillas el anterior while y descomentar el de abajo +""" +""" +caja1 = 0 +while caja1 < 10: # Mientras caja1 sea menor que 10 se repetira el bucle + imprimir(f"caja1 vale={caja1}") # Imprimimos un mensaje cada vez que se repite el bucle, mostramos lo que vale caja1 + dormir(1) # Esperamos 1 segundo entre repeticiones + caja1 = caja1 + 1 # Sumamos 1 al valor que tenga caja, si caja1 = 0 y le sumamos 1 caja1 ahora vale 1 +""" \ No newline at end of file diff --git a/05_bucles_infinitos_practica.py b/05_bucles_infinitos_practica.py new file mode 100644 index 0000000..b0d21e7 --- /dev/null +++ b/05_bucles_infinitos_practica.py @@ -0,0 +1,43 @@ +from taller_programacion import * +""" +Movemos los leds a la derecha sin parar! + +""" + +luces.pintarArcoiris() # Pintamos un arcoiris +while cierto: # Mientras se cumpla la condición se repetira todo el rato lo que hay escrito en el + luces.moverDerecha() # Movemos las luces a la derecha + luces.iluminar() # Las iluminamos + dormir(0.2) # Esperamos entre repeticiones + # Volvemos a empezar + +""" +Movemos los leds a la derecha hasta que giremos el mando1 + +""" +""" +luces.pintarArcoiris() # Pintamos un arcoiris +while mandos.posiciones_mando1 == 0: # Mientras se cumpla la condición se repetira todo el rato lo que hay escrito en el + luces.moverDerecha() # Movemos las luces a la derecha + luces.iluminar() # Las iluminamos + dormir(0.2) # Esperamos entre repeticiones + # Volvemos a empezar +""" + +""" +Movemos los leds a la derecha tantas veces como giramos el mando1 + +""" +""" +luces.borrar() # Borramos lo anteriormente pintado +luces.pintarLed(25, "blanco") # Pintamos un punto blanco en medio +luces.iluminar() # iluminamos +while cierto: # Mientras se cumpla la condición se repetira todo el rato lo que hay escrito en el + valor_mando1 = mandos.posiciones_mando1 # Guardamos el valor de las posiciones que se ha movido el mando + if valor_mando1 > 0: # Si hemos girado el mando1 + luces.moverDerecha(pasos=valor_mando1) # Movemos las luces a la derecha los mismos pasos que hemos girado + luces.iluminar() # Las iluminamos + dormir(0.2) # Esperamos entre repeticiones + # Volvemos a empezar + +""" \ No newline at end of file diff --git a/06_bucles_finitos.py b/06_bucles_finitos.py new file mode 100644 index 0000000..614166f --- /dev/null +++ b/06_bucles_finitos.py @@ -0,0 +1,31 @@ +from taller_programacion import * +""" +Los bucles finitos nos permiten repetir un código el número de veces que queramos, estos siempre tienen que acabar! + +Que es un bucle finito? + +Ejemplo: + Por cada ficha daremos un viaje en la noria + Por cada dia que trabajes te pagaré 20€ + Por cada led mueve las luces a la derecha (las luces se moveran a la derecha tantas veces como leds hay) + +La palabra clave aquí es "por" que en programación se traduce en "for" y se escribe así: + +for "cosa que se puede contar": + repetimos tantas veces como cosas hay + + +Vamos por un ejemplo real: +""" + + +""" +Si queremos que algo se repita un número fijo de veces lo podemos hacer así: +""" + +for vuelta in range(10): # El bucle se repetira 10 veces, cada vez vuelta tendrá el valor de la vuelta actual. Primero 1, luego 2 etc... + imprimir(vuelta) + dormir(0.5) + + + diff --git a/06_bucles_finitos_practica.py b/06_bucles_finitos_practica.py new file mode 100644 index 0000000..97b54c7 --- /dev/null +++ b/06_bucles_finitos_practica.py @@ -0,0 +1,13 @@ +from taller_programacion import * +""" +Pintemos 10 luces a la vez! +""" +luces.borrar() # Borramos lo que haya pintado anteriormente +for numero in range(10): # El bucle se repetira 10 veces, cada vez vuelta tendrá el valor de la vuelta actual. Primero 1, luego 2 etc... + imprimir(numero) # Imprimimos el numero que vamos a pintar + luces.pintarLed(numero_de_led=numero,color="verde") # Pintamos el numero de esta vuelta de bucle + luces.iluminar() # Los iluminamos para poder verlos + dormir(0.5) # Esperamos y seguimos el bucle + + + diff --git a/P01_colores_o_blanco.py b/P01_colores_o_blanco.py new file mode 100644 index 0000000..d8064d6 --- /dev/null +++ b/P01_colores_o_blanco.py @@ -0,0 +1,69 @@ +from taller_programacion import * +""" +Que pasa si pintamos los colores rojo, verde y azul en leds juntos y los movemos cada vez más rápido? +Vemos los colores o vemos un color distinto? +""" + +imprimir("Vamos a hacer una prueba con colores y nuestros ojos") # Mandamos un mensaje a la consola + +luces.pintarLed(1, color="rojo") # Pintamos un led de cada color principal, rojo, verde y azul +luces.pintarLed(2, color="verde") +luces.pintarLed(3, color="azul") +luces.iluminar() # Los encendemos + +contador = 0 # Creamos una variable que se llama contador, le iremos sumando 1 en cada vuelta del bucle +""" +Movemos los colores a la derecha pero un poco lentos +""" +imprimir("Muevo los leds no muy rápido, vemos los 3 colores") # Mandamos un mensaje a la consola +while contador < 200: # Mientras contador sea menor a 200 (Significa que esto se repetirá 200 veces) + luces.moverDerecha() # Movemos las luces a la derecha + luces.iluminar() # Las iluminamos + contador = contador + 1 # Sumamos 1 a contador + dormir_ms(20) # Esperamos un tiempo pequeño antes de volver a mover a la derecha otra vez, las luces se moveran no muy rápido + +dormir(1) # Hacemos una pausa antes de seguir +contador = 0 # Volvemos a poner a 0 el contador + +""" +Movemos los colores a la derecha pero algo mas rápido +""" +imprimir("Muevo los leds algo más rápido, vemos los 3 colores?") # Mandamos un mensaje a la consola +while contador < 400: # Mientras contador sea menor a 400 (Significa que esto se repetirá 400 veces) + luces.moverDerecha() # Movemos las luces a la derecha + luces.iluminar() # Las iluminamos + contador = contador + 1 # Sumamos 1 a contador + dormir_ms(10) # Esperamos un tiempo pequeño antes de volver a mover a la derecha otra vez, las luces se moveran no muy rápido + +dormir(1) # Hacemos una pausa antes de seguir +contador = 0 # Volvemos a poner a 0 el contador + +""" +Movemos los colores a la derecha pero bastante rápido +""" +imprimir("Muevo los leds algo rápido, casi no se ven los 3 colores verdad?") # Mandamos un mensaje a la consola +while contador < 600: # Mientras contador sea menor a 600 (Significa que esto se repetirá 600 veces) + luces.moverDerecha() # Movemos las luces a la derecha + luces.iluminar() # Las iluminamos + contador = contador + 1 # Sumamos 1 a contador + dormir_ms(5) # Esperamos un tiempo pequeño antes de volver a mover a la derecha otra vez, las luces se moveran no muy rápido + +dormir(1) # Hacemos una pausa antes de seguir +contador = 0 # Volvemos a poner a 0 el contador + +""" +Movemos los colores a la derecha muy rápido +""" +imprimir("Muevo los leds muy rápido, yo solo veo el color blanco!") # Mandamos un mensaje a la consola +while contador < 1000: # Mientras contador sea menor a 1000 (Significa que esto se repetirá 1000 veces) + luces.moverDerecha() # Movemos las luces a la derecha + luces.iluminar() # Las iluminamos + contador = contador + 1 # Sumamos 1 a contador + dormir_ms(1) # Esperamos un tiempo pequeño antes de volver a mover a la derecha otra vez, las luces se moveran no muy rápido + +dormir(1) # Hacemos una pausa antes de seguir +contador = 0 # Volvemos a poner a 0 el contador + +imprimir("\nEsto pasa porque nuestro ojo que es mas lento que lo que se mueven las luces, ") # Mandamos un mensaje a la consola +imprimir("junta los 3 colores apareciendo entonces el color blanco para nosotros, ") # Mandamos un mensaje a la consola +imprimir("aunque solo sean los colores ROJO, VERDE y AZUL moviéndose muy rápido") # Mandamos un mensaje a la consola \ No newline at end of file diff --git a/README.md b/README.md index 192f46a..db14c7b 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,19 @@ -# 2024_Taller_Programacion_Oris +# 2024 Taller Programacion Oris + +_Ejemplos y pequeñas prácticas para ampliar lo explicado en el curso._ + + +## Prácticas + +1. [Práctica 01. 3 Colores o color blanco?](P01_colores_o_blanco.py "Práctica 01 Colores o color blanco?") + + +### Instrucciones y consejos: + +· Hay que tener subidos a nuestra placa siempre los archivos __requerimientos.py__ y __taller_programación.py__ +· Si vamos a programar es mejor eliminar el archivo __main.py__ de nuestra plaquita. +· Para poder tener nuestro juego funcionando sin estar conectado al ordenador, copiaremos el archivo __main.py__ a nuestra plaquita. + + + -Ejemplos y pequeñas prácticas para ampliar lo explicado en el curso. \ No newline at end of file diff --git a/main.py b/main.py new file mode 100644 index 0000000..9d4d753 --- /dev/null +++ b/main.py @@ -0,0 +1,37 @@ +""" +Programa principal juego para taller de programacion 2024 Orís +ModoComún + +""" + +from taller_programacion import * # Cargamos todo lo necesario para nuestro juego + + +async def main(): # Este es el inicio del programa principal + + logger.info(f"Iniciamos programa") # Informamos de que comenzamos nuestro programa + tablero = Tablero(casillas_totales=50) # Cargamos el tablero de juego con X posiciones que son la cantidad de leds + + while True: # Bucle infinito principal, este trozo se repetira siempre + # El programa irá pasando por diferentes fases dependiendo del momento en que esté + if tablero.__fase == "brillo": # En esta fase los jugadores pueden elegir el brillo de los leds + await asyncio.wait_for(tablero.seleccionarBrillo(),600) + elif tablero.__fase == "puntos": # En esta fase los jugadores pueden elegir los puntos de la partida + await asyncio.wait_for(tablero.seleccionarPuntos(),600) + elif tablero.__fase == "color": # En esta fase los jugadores pueden elegir el color de su portería + await asyncio.wait_for(tablero.seleccionarColor(),600) + elif tablero.__fase == "largo": # En esta fase los jugadores pueden elegir el largo de su porteria + await asyncio.wait_for(tablero.seleccionarLargo(),600) + elif tablero.__fase == "inicio": # En esta fase empieza el jugador que primero pulse su botón + await asyncio.wait_for(tablero.inicio(),600) + elif tablero.__fase == "juego": # En esta fase los jugadores juegan hasta que se consigan los puntos de la partida + await asyncio.wait_for(tablero.juegoPrincipal(),3600) + elif tablero.__fase == "final": # Esta fase no está definida aún + tablero.actualizar() + else: + tablero.__fase = "brillo" # Si no hay ninguna fase seleccionada nos vamos a brillo + await asyncio.sleep_ms(0) # Esperamos 0 segundos, esto se hace para que el programa pueda atender otras cosas antes de volver a revisar las fases + +asyncio.run(main()) # Ejecutamos la función de main (La de aquí arriba) + + \ No newline at end of file diff --git a/requerimientos.py b/requerimientos.py new file mode 100644 index 0000000..12211d9 --- /dev/null +++ b/requerimientos.py @@ -0,0 +1,20 @@ +from time import sleep,ticks_ms, sleep_ms # Librería para utilizar instrucciones de tiempo como el sleep +sleep(2) # Esperamos X segundos por si queremos detener el programa al conectar al PC etc... +""" La primera librería es la de log, necesitamos definirlo para que pueda loguear correctamente las demas librerías """ +from mc_log import miLog, escribirLog # Librería para usar el log +logger = miLog(nivel="INFO", consola=True, archivo=False) # Creamos el log y así podrá trabajar también con las demás librerías +""" Para que se guarde el log en el archivo hay que hacer un soft reset. Usar Ctrl+D después del stop en Thonny + IMPORTANTE, crear la carpeta /logs en el micro si se usa log en archivo """ +from neopixel import NeoPixel # Librería para controlar la tira de leds con chip WS2812 +import random # Librería para generar unos números aleatorio mas adelante +import machine # Librería con las instrucciones para acceder a los periféricos del ESP +import uasyncio as asyncio # Librería para usar asyncio, permite simular varios procesos al mismo tiempo +machine.freq(240000000) # Configuramos la frecuencia de la CPU a 240 MHz +import time # Librería para utilizar instrucciones de tiempo como el sleep +from micropython import const # Para poder utilizar las constantes +try: + import numpy as np # Importamos Numpy, permite trabajar con matrices cómodamente +except: + from ulab import numpy as np # Si no se puede importar la anterior importamos la versión de micropython + +from rotary_irq_esp import RotaryIRQ # Librería para utilizar los encoders rotatorios \ No newline at end of file diff --git a/taller_programacion.py b/taller_programacion.py new file mode 100644 index 0000000..5edc9a0 --- /dev/null +++ b/taller_programacion.py @@ -0,0 +1,1168 @@ +from requerimientos import * + +COLORES = dict() #Definimos una serie de colores pre-definidos en un diccionario +COLORES["rojo"] = np.array([ 0, 255, 0 ], dtype=np.uint8) +COLORES["blanco"] = np.array([ 255, 255, 255 ], dtype=np.uint8) +COLORES["negro"] = np.array([ 0, 0, 0 ], dtype=np.uint8) +COLORES["magenta"] = np.array([ 0, 255, 255 ], dtype=np.uint8) +COLORES["lila"] = np.array([ 0, 128, 255 ], dtype=np.uint8) +COLORES["azul"] = np.array([ 0, 0, 255 ], dtype=np.uint8) +COLORES["azul_claro"] = np.array([ 128, 0, 255 ], dtype=np.uint8) +COLORES["cian"] = np.array([ 255, 0, 255 ], dtype=np.uint8) +COLORES["turquesa"] = np.array([ 255, 0, 128 ], dtype=np.uint8) +COLORES["verde"] = np.array([ 255, 0, 0 ], dtype=np.uint8) +COLORES["lima"] = np.array([ 255, 128, 0 ], dtype=np.uint8) +COLORES["amarillo"] = np.array([ 255, 255, 0 ], dtype=np.uint8) +COLORES["naranja"] = np.array([ 128, 255, 0 ], dtype=np.uint8) + +cierto = const(True) +falso = const(False) + + +def dormir(tiempo): + """ Permite parar el programa un tiempo determinado. + El tiempo puede ser en segundos 1, 2, 3... o puede ser menor de un segundo -> 0.1 (100ms) + Ejemplo: + dormir(50) # Esperará durante 50s + """ + sleep(tiempo) + +def dormir_ms(tiempo): + """ Permite parar el programa un tiempo determinado. + El tiempo es en milisegundos, 100ms son 0.1s. + Ejemplo: + dormir_ms(50) # Esperará durante 50ms + """ + sleep_ms(tiempo) + + +def imprimir(mensaje): + """ Muestra un mensaje en la consola del ordenador, es útil para ver información rápido + Si colocas una variable entre corchetes mostrará su valor, ejemplo: + f"Esto es un mensaje y el valor de X es: {X}" + """ + print(mensaje) + +def esperarParaSiempre(): + """ El programa se parará aquí indefinidamente, hay que pulsar stop para para parar el programa. + Ejemplo: + esperarParaSiempre() + """ + while True: + sleep(1) + +class MiTiraDeLeds(): + """ + Es la tira con luces, con ella podemos hacer lo siguiente: + - pintarLed(numero_led, color): Pintar un led de un color + - iluminar(): Enciende los leds en la tira con los colores que se hayan pintado + - borrar(): borrar todas las luces + - moverDerecha(pasos): Mueve todos los colores a la derecha + - moverIzquierda(pasos): Mueve todos los colores a la izquierda + - pintarArcoiris(): Pinta un arcoiris + Ejemplo: + leds = MiTiraDeLeds() # Para usar la configuración por defecto + o + leds = MiTiraDeLeds(cantidad_de_leds=100) #si queremos cambiar la cantidad de leds + """ + def __init__(self, pin:int=12, cantidad_de_leds:int=50) -> None: + _pin = pin + self._cantidad_de_leds = cantidad_de_leds + __pinNeoPixel = machine.Pin(12, machine.Pin.OUT) + self.__tira_leds = NeoPixel(__pinNeoPixel, self._cantidad_de_leds) + self.__capa = np.zeros((self._cantidad_de_leds,3), dtype=np.uint8) + self.__brillo = 0.5 + self.__lista_colores_arcoiris = ["naranja", "amarillo","lima", "verde", "turquesa", "cian", "azul_claro" , "azul", "lila", "magenta", "rojo"] + + def __str__(self):#Sobreescribimos el valor str por defecto de la clase con un texto + return f"Soy una tira de luces con {self._cantidad_de_leds} leds" + def __len__(self):#Devolvemos un valor al llamar a len(objeto) + return self._cantidad_de_leds + + def iluminar(self): + """ + Enciende las luces con los colores que se hayan pintado, hay que hacerlo cada vez justo después de pintar para que los podamos ver + Ejemplo: + luces.iluminar() + """ + self.__tira_leds.buf = self.__capa.tobytes() # Nos saltamos el método __set_item__ y escribimos los colores directamente en formato bytearray + self.__tira_leds.write() + + def pintarLed(self, numero_de_led, color:str="azul"): + """ + Pintamos una luz del color que queramos, hay que decirle el número del led que queremos y el color, ejemplo: + Ejemplo: + luces.pintarLed(numero_de_led=1, color="verde") + o + luces.pintarLed(1, "verde") + + luces.iluminar() + """ + if numero_de_led <= self._cantidad_de_leds and numero_de_led > 0: + self.__capa[numero_de_led-1] = np.array(COLORES[color], dtype=np.uint8)*(self.__brillo) + else: + logger.warning(f"El numero de led que se quiere pintar ->{numero_de_led}<- está fuera de rango\nEl número debe ir entre 1 y {self._cantidad_de_leds} ") + + def borrar(self): + """ + Borra todos los colores, para ver las luces apagadas hay que usar iluminar. + Ejemplo: + luces.borrar() + luces.iluminar() + """ + self.__capa = np.zeros((self._cantidad_de_leds,3), dtype=np.uint8) + + def moverDerecha(self, pasos:int=1): + """ + Mueve todas las luces a la derecha una cantidad de pasos. + Ejemplo: + luces.moverDerecha() <- Moverá un paso a la derecha + luces.moverDerecha(pasos=2) <- Moverá dos paso a la derecha + luces.iluminar() + """ + self.__capa = np.roll(self.__capa,pasos * 3) + + def moverIzquierda(self, pasos:int=1): + """ + Mueve todas las luces a la izquierda una cantidad de pasos. + Ejemplo: + luces.moverIzquierda() <- Moverá un paso a la izquierda + luces.moverIzquierda(pasos=2) <- Moverá dos paso a la izquierda + luces.iluminar() + """ + self.__capa = np.roll(self.__capa,pasos * -3) + + def pintarArcoiris(self): + """ + Pinta un arcoiris de colores. + Ejemplo: + luces.pintarArcoiris() + luces.iluminar() + """ + self.__posicion_arcoiris = 0 + self.__capa_arcoiris = np.zeros((self._cantidad_de_leds,3), dtype=np.uint8) + self.__capa = np.zeros((self._cantidad_de_leds,3), dtype=np.uint8) + casillas_por_color = int(self._cantidad_de_leds/len(self.__lista_colores_arcoiris)) + casillas_libres = self._cantidad_de_leds - casillas_por_color * len(self.__lista_colores_arcoiris) + posicion = 0 + for num, color in enumerate(self.__lista_colores_arcoiris): + self.__capa_arcoiris[posicion:posicion+casillas_por_color+casillas_libres] = np.array(COLORES[color], dtype=np.uint8)*(self.__brillo) + posicion = posicion + casillas_por_color + casillas_libres + if num == 0: + casillas_libres = 0 + self.__capa = self.__capa_arcoiris + if self.__posicion_arcoiris != 0: + self.__capa = np.roll(self.__capa_arcoiris, 3*self.__posicion_arcoiris) + self.__posicion_arcoiris += 1 + if self.__posicion_arcoiris >= self._cantidad_de_leds: + self.__posicion_arcoiris = 0 + @property + def cantidad_de_leds(self): + return self._cantidad_de_leds + + +class MisMandos(): + """ + Los mandos con los que jugaremos al juego, con ellos podemos: + - imprimirPasos("SI" o "NO"): Escribe por consola cada vez que se mueve un mando + - imprimirBotones("SI" o "NO"): Escribe por consola cada vez que se pulsa un mando + - giroMando1(): Es Verdadero si el mando ha girado, falso si no se ha movido + - giroMando2(): Es Verdadero si el mando ha girado, falso si no se ha movido + - posiciones_mando1: Son la cantidad de pasos que el mando se ha movido + - posiciones_mando2: Son la cantidad de pasos que el mando se ha movido + - boton1Pulsado(): Es Verdadero si el mando se ha pulsado, falso si no se ha pulsado + - boton2Pulsado(): Es Verdadero si el mando se ha pulsado, falso si no se ha pulsado + + """ + def __init__(self) -> None: + self.r2 = RotaryIRQ(pin_num_clk=27, + pin_num_dt=14, + min_val=0, + max_val=20, + reverse=False, + range_mode=RotaryIRQ.RANGE_UNBOUNDED) + self.r1 = RotaryIRQ(pin_num_clk=33, + pin_num_dt=25, + min_val=0, + max_val=20, + reverse=False, + range_mode=RotaryIRQ.RANGE_UNBOUNDED) + + self.r1.add_listener(self.__llamada_mando1) + self.r2.add_listener(self.__llamada_mando2) + self.imprimir_pasos = "NO" + self.__posiciones_mando_p1 = 0 + self.__posiciones_mando_p2 = 0 + self.__valor_mando_p2 = 0 + self.__valor_mando_p1 = 0 + + self.__pin1 = machine.Pin(32, machine.Pin.IN, machine.Pin.PULL_UP) + self.__pin1.irq(trigger=machine.Pin.IRQ_FALLING, handler=self.__llamada_boton1) + self.__pin2 = machine.Pin(26, machine.Pin.IN, machine.Pin.PULL_UP) + self.__pin2.irq(trigger=machine.Pin.IRQ_FALLING, handler=self.__llamada_boton2) + self.__pulsacion_b1 = False + self.__pulsacion_b2 = False + self.__imprimir_botones = "NO" + + self.__tiempo_antirebote = 200 + self.__temporizadorB1 = Temporizador(self.__tiempo_antirebote) + self.__temporizadorB2 = Temporizador(self.__tiempo_antirebote) + self.__temporizadorB1.iniciar(self.__tiempo_antirebote) + self.__temporizadorB2.iniciar(self.__tiempo_antirebote) + + def __str__(self):#Sobreescribimos el valor str por defecto de la clase con un texto + return f"Tenemos 2 mandos que son unos encoders rotatorios con pulsadores" + + + def imprimirPasos(self, valor:str="SI"): + """ + Imprime por consola cada vez que un mando se gira si el valor es "SI", si es "NO" no hace nada + Ejemplo: + mandos.imprimirPasos("SI") + """ + self.__imprimir_pasos = valor + + def imprimirBotones(self, valor:str="SI"): + """ + Imprime por consola cada vez que un mando se pulsa si el valor es "SI", si es "NO" no hace nada + Ejemplo: + mandos.imprimirBotones("SI") + """ + self.__imprimir_botones = valor + + def __llamada_mando1(self): + if self.__valor_mando_p1 != self.r1.value(): + self.__posiciones_mando_p1 += self.r1.value() - self.__valor_mando_p1 + self.__valor_mando_p1 = self.r1.value() + if self.__imprimir_pasos == "SI": print(f"Mando 1: Valor={self.r1.value()}, posiciones={self.__posiciones_mando_p1} ") + + def __llamada_mando2(self): + if self.__valor_mando_p2 != self.r2.value(): + self.__posiciones_mando_p2 += self.r2.value() - self.__valor_mando_p2 + self.__valor_mando_p2 = self.r2.value() + if self.__imprimir_pasos == "SI": print(f"Mando 2: Valor={self.r2.value()}, posiciones={self.__posiciones_mando_p2} ") + + def __llamada_boton1(self,p): + if self.__temporizadorB1.fin(): + self.__temporizadorB1.iniciar(self.__tiempo_antirebote) + self.__pulsacion_b1 = True + if self.__imprimir_botones == "SI": print(f"Botón 1: Valor={self.__pulsacion_b1}") + + def __llamada_boton2(self,p): + if self.__temporizadorB1.fin(): + self.__temporizadorB1.iniciar(self.__tiempo_antirebote) + self.__pulsacion_b2 = True + if self.__imprimir_botones == "SI": print(f"Botón 2: Valor={self.__pulsacion_b2}") + + def giroMando1(self) -> bool: + """ + Devuelve Verdadero si el mando ha girado, falso si no se ha movido. + Ejemplo: + if mandos.giroMando1(): + imprimir("El mando 1 ha girado") + """ + if self.__posiciones_mando_p1: + return True + else: + return False + + def giroMando2(self) -> bool: + """ + Devuelve Verdadero si el mando ha girado, falso si no se ha movido. + Ejemplo: + if mandos.giroMando2(): + imprimir("El mando 2 ha girado") + """ + if self.__posiciones_mando_p2: + return True + else: + return False + + @property + def posiciones_mando1(self) -> int: + """ + Devuelve la cantidad de posiciones o pasos que ha girado el mando. + Ejemplo: + pasos = mandos.posiciones_mando1 + """ + try: + return self.__posiciones_mando_p1 + finally: + self.__posiciones_mando_p1 = 0 + + @property + def posiciones_mando2(self) -> int: + """ + Devuelve la cantidad de posiciones o pasos que ha girado el mando. + Ejemplo: + pasos = mandos.posiciones_mando2 + """ + try: + return self.__posiciones_mando_p2 + finally: + self.__posiciones_mando_p2 = 0 + + def boton1Pulsado(self): + """ + Devuelve Verdadero si el mando se ha pulsado, falso si no se ha pulsado. + Ejemplo: + if mandos.boton1Pulsado(): + imprimir("El mando 1 ha sido pulsado") + """ + try: + if self.__pulsacion_b1: + return True + finally: + self.__pulsacion_b1 = False + + def boton2Pulsado(self): + """ + Devuelve Verdadero si el mando se ha pulsado, falso si no se ha pulsado. + Ejemplo: + if mandos.boton2Pulsado(): + imprimir("El mando 2 ha sido pulsado") + """ + try: + if self.__pulsacion_b2: + return True + finally: + self.__pulsacion_b2 = False + + +class Bola: + #Constructor, __init__ solo se ejecuta al crearse, osea, una vez + def __init__(self, posicion:int=8, color:str="blanco"): #Inicializamos la clase y recogemos los argumentos a la hora de crearse + + self.__color = color + self.__color_temporal = self.__color + self.__posicion = posicion + self.__largo = 1 + + def __str__(self):#Sobreescribimos el valor str por defecto de la clase con un texto + return f"Soy una bola de color {self.__color} y estoy en la posición {self.__posicion}" + def __len__(self):#Devolvemos un valor al llamar a len(objeto) + return self.__largo + + @property + def posicion(self): + return self.__posicion + @posicion.setter + def posicion(self, valor:int): + self.__posicion = valor + + @property + def color(self): + return self.__color + @color.setter + def color(self, valor:str): + if valor in COLORES: + self.__color = valor + else: + logger.warning(f"El color elegido no existe") + + def ocultar(self): + self.__color_temporal = self.__color + self.__color = "negro" + + def mostrar(self): + self.__color = self.__color_temporal + + def moverDerecha(self, posiciones:int=1): + __posiciones = posiciones + __casilla_destino = self.__posicion + __posiciones + if __casilla_destino < 50: # Si estamos dentro del rango + self.__posicion += __posiciones + self.__casillas = np.roll(self.__casillas, __posiciones * 3) + return True + else: # Nos hemos salido del rango, nos movemos solo hasta el extremo + __posiciones = (len(self.__casillas)) - self.__posicion - 1 + self.__posicion = (len(self.__casillas))-1 + if __posiciones != 0: + self.__casillas = np.roll(self.__casillas, __posiciones * 3) + return False + + def moverIzquierda(self, posiciones:int=1): + __posiciones = posiciones + __casilla_destino = self.__posicion - __posiciones + if __casilla_destino >= 0: + self.__posicion -= __posiciones + self.__casillas = np.roll(self.__casillas, -__posiciones * 3) + return True + else: + __posiciones = self.__posicion + self.__posicion = 0 + if __posiciones != 0: + self.__casillas = np.roll(self.__casillas, -__posiciones * 3) + return False + + @property # Mejor no usar en bucle porque devuelve una copia de toda la array y es muy lento + def leer(self): + return self.__casillas + + +class Porteria: + def __init__(self, largo:int=8, posicion:int=8, color:str="rojo"): #Inicializamos la clase y recogemos los argumentos a la hora de crearse + self.__posicion = posicion + + self.__color = color + self.__largo = largo + + def __str__(self):#Sobreescribimos el valor str por defecto de la clase con un texto + return f"Soy una porteria de color {self.__color}, hago {self.__largo} de largo y estoy en la posición {self.__posicion}" + def __len__(self):#Devolvemos un valor al llamar a len(objeto) + return len(self.__largo) + + @property + def largo(self): + return self.__largo + @largo.setter + def largo(self, valor:int): + self.__largo = valor + + + @property + def color(self): + return self.__color + @color.setter + def color(self, valor:str): + if valor in COLORES: + self.__color = valor + else: + logger.warning(f"El color elegido no existe") + + @property + def posicion(self): + return self.__posicion + @posicion.setter + def posicion(self, valor:int): + self.__posicion = valor + +class Temporizador: + """ + Inicia un temporizador el cual podemos consultar si ha pasado el tiempo + Ejemplo: + temporizador.iniciar(tiempo_ms=1000) # El temporizador contara 1 segundo + """ + def __init__(self,tiempo_ms:int=100) -> None: + self.__tiempo_ms = tiempo_ms + self.__t = 0 + + def iniciar(self,tiempo_ms:int=100) -> None: + """ + Inicia el temporizador + Ejemplo: + temporizador.iniciar(tiempo_ms=1000) # El temporizador contara 1 segundo + """ + self.__t = time.ticks_ms() + + def fin(self) -> bool: + """ + Para comprobar si el temporizador ha finalizado, devuelve Verdadero si ha acabado sino Falso + Ejemplo: + if temporizador.fin(): # Si el temporizador ha acabado + """ + if time.ticks_diff(time.ticks_ms(), self.__t) >= self.__tiempo_ms: + return True + else: + return False + +class VelocidadYTiempo: + def __init__(self, velocidad_min:int=150) -> None: + self.__tiempo_inicio = 0 + self.__tiempo_juego = 0 + self.__velocidad = velocidad_min + self.__lista_velocidades = [200, 150, 75, 50, 25, 15, 10, 5, 4, 3, 2, 1, 0] + self.__posicion_velocidad = 0 + + @property + def tiempo_juego(self): + return self.__tiempo_juego/1000 + @property + def velocidad(self): + return self.__velocidad + + def iniciarTiempo(self): + self.__tiempo_inicio = time.ticks_ms() + self.__tiempo_juego = 0 + + self.generador_tiempo_cambio = self.generarTiemposVelocidad(tiemp_min=1, tiemp_max=5) + self.__tiempo_siguiente_cambio = next(self.generador_tiempo_cambio) + # logger.info(f"Iniciar Tiempo:\n self.__tiempo_inicio={self.__tiempo_inicio}, self.__tiempo_juego={self.__tiempo_juego}, self.__tiempo_siguiente_cambio={self.__tiempo_siguiente_cambio}") + + def tiempoCompletado(self) -> bool: + self.__tiempo_juego = time.ticks_diff(time.ticks_ms(), self.__tiempo_inicio) + if int(self.__tiempo_juego/1000) > self.__tiempo_siguiente_cambio: + self.__tiempo_siguiente_cambio = next(self.generador_tiempo_cambio) + # logger.info(f"tiempoCompletado:\nself.__tiempo_siguiente_cambio={self.__tiempo_siguiente_cambio}") + return True + else: + return False + + def reiniciarVelocidad(self): + self.iniciarTiempo() + self.generador_velocidad = self.generarVelocidad() + self.__velocidad = next(self.generador_velocidad) + # logger.info(f"reiniciar Velocidad:\nvelocidad={self.__velocidad}") + return self.__velocidad + + def cambiosDeVelocidad(self): + if self.__velocidad == 0: + return self.__velocidad + else: + if self.tiempoCompletado(): + return self.cambiarVelocidad() + else: + return self.__velocidad + + def cambiarVelocidad(self, pasos:int=1) -> int: + + self.__velocidad = next(self.generador_velocidad) + # logger.info(f"Velocidad CAMBIADA={self.__velocidad}") + return self.__velocidad + + def incrementarVelocidad(self): + pass + + def generarVelocidad(self, pasos:int=1) -> int: + posicion = 0 + while 1: + if pasos>=0: + if posicion + pasos >= len(self.__lista_velocidades): + posicion = len(self.__lista_velocidades) -1 + else: + posicion += pasos + else: + if posicion + pasos <= 0: + posicion = 0 + else: + posicion += pasos + yield self.__lista_velocidades[posicion] + + def generarListaTiemos(self): + pass + + def generarTiemposVelocidad(self, tiemp_min:int=3, tiemp_max:int=30) -> int: + """ + PLANTILLA DE DIFICULTAD + """ + plantilla = [ # Velocidad + [5, 10], # 200 + [5, 10], # 150 + [5, 10], # 75 + [15, 30], # 50 + [15, 30], # 25 + [15, 30], # 15 + [15, 30], # 10 + [15, 30], # 5 + [20, 40], # 4 + [20, 40], # 3 + [20, 60], # 2 + [20, 80], # 1 + [60, 80] # 0 + ] + t = 0 + posicion = 0 + while 1: + # t += random.randrange(tiemp_min,tiemp_max) + try: + t +=random.randrange(plantilla[posicion][0],plantilla[posicion][1]) + posicion += 1 + if posicion >= len(plantilla): + posicion -= 1 + + except: + t += plantilla[12][0] + yield t + + """ + Necesito una lista de tiempos no lineal y dependiendo de la dificultad + self.__lista_velocidades = [200, 150, 75, 50, 25, 15, 10, 5, 4, 3, 2, 1, 0] + """ + +class Tablero: + def __init__(self, casillas_totales:int=50, pin_boton_1:int=32, pin_boton_2:int=26) -> None: #Inicializamos la clase y recogemos los argumentos a la hora de crearse + self.__casillas_totales = casillas_totales + + self.r2 = RotaryIRQ(pin_num_clk=27, + pin_num_dt=14, + min_val=0, + max_val=20, + reverse=False, + range_mode=RotaryIRQ.RANGE_UNBOUNDED) + self.r1 = RotaryIRQ(pin_num_clk=33, + pin_num_dt=25, + min_val=0, + max_val=20, + reverse=False, + range_mode=RotaryIRQ.RANGE_UNBOUNDED) + + self.myevent = asyncio.Event() + asyncio.create_task(self.action()) + self.r1.add_listener(self.callback) + self.r2.add_listener(self.callback) + + self.__pin1 = machine.Pin(pin_boton_1, machine.Pin.IN, machine.Pin.PULL_UP) + self.__pin1.irq(trigger=machine.Pin.IRQ_FALLING, handler=self.__cbBotonP1) + self.__pin2 = machine.Pin(pin_boton_2, machine.Pin.IN, machine.Pin.PULL_UP) + self.__pin2.irq(trigger=machine.Pin.IRQ_FALLING, handler=self.__cbBotonP2) + self.__temporizadorP1 = Temporizador(tiempo_ms=250) + self.__temporizadorP2 = Temporizador(tiempo_ms=250) + + self.__brillo_general = 40 + self.__brillo_bola = 100 + self.__brillo_porterias = 75 + self.__brillo_puntos = 75 + self.__brillo_fondo_puntos = 50 + self.__bola = Bola(posicion=25, color="blanco") + # logger.info(f"self.__bola:\n{self.__bola}") + self.__capa_bola = np.zeros((self.__casillas_totales,3), dtype=np.uint8) + + + self.__lista_colores = ["lima", "verde", "turquesa", "cian", "azul_claro" , "azul", "lila", "magenta", "rojo"] + self.__lista_colores_arcoiris = ["naranja", "amarillo","lima", "verde", "turquesa", "cian", "azul_claro" , "azul", "lila", "magenta", "rojo"] + self.color_p1 = "naranja" + self.color_p2 = "amarillo" + self.color_fondo_puntos = "rojo" + self.color_puntos = "verde" + self.__porteria1 = Porteria(largo=10, posicion=0, color=self.color_p1) + logger.info(f"self.__porteria1:\n{self.__porteria1}") + self.__porteria2 = Porteria(largo=10, posicion=self.__casillas_totales-10, color=self.color_p2) + logger.info(f"self.__porteria2:\n{self.__porteria2}") + self.__capa_porterias = np.zeros((self.__casillas_totales,3), dtype=np.uint8) + self.__capa_porterias[0:self.__porteria1.largo] = np.array(COLORES[self.__porteria1.color], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_porterias/100) + self.__capa_porterias[self.__porteria2.posicion:self.__porteria2.posicion+self.__porteria2.largo] = np.array(COLORES[self.__porteria2.color], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_porterias/100) + self.capa_salida = np.zeros((self.__casillas_totales,3), dtype=np.uint8) + self.__velocidad = 250 + self.__direccion = 0 + self.__pulsador = 0 + self.__fase = "brillo" + self.__dificultad = 5 + self.__empezar_p1 = False + self.__empezar_p2 = False + self.__puntos_p1 = 0 + self.__puntos_p2 = 0 + self.__puntos_max = 5 + self.__valor_encoder_p1 = self.r1.value() + self.__valor_encoder_p2 = self.r2.value() + self.__posiciones_encoder_p1 = 0 + self.__posiciones_encoder_p2 = 0 + self.__posicion_arcoiris = 0 + self.__tiempoVelocidad = VelocidadYTiempo() + + __pinNeoPixel = machine.Pin(12, machine.Pin.OUT) + self.__tira_leds = NeoPixel(__pinNeoPixel, self.__casillas_totales) + + + def callback(self): + self.myevent.set() + + async def action(self): + while True: + await self.myevent.wait() + if self.__valor_encoder_p1 != self.r1.value(): + self.__posiciones_encoder_p1 = self.r1.value() - self.__valor_encoder_p1 + self.__valor_encoder_p1 = self.r1.value() + if self.__valor_encoder_p2 != self.r2.value(): + self.__posiciones_encoder_p2 = self.r2.value() - self.__valor_encoder_p2 + self.__valor_encoder_p2 = self.r2.value() + self.myevent.clear() + + def __str__(self): # Sobreescribimos el valor str por defecto de la clase con un texto + return f"Soy una bola de color {self.__color} y estoy en la posición {self.__posicion}" + def __len__(self): # Devolvemos un valor al llamar a len(objeto) + return len(self.__casillas) + + def __cbBotonP1(self,p): + if self.__temporizadorP1.fin(): + # logger.info(f"{ticks_ms()}: P1") + self.__pulsador = 1 + self.__temporizadorP1.iniciar() + + def __cbBotonP2(self,p): + if self.__temporizadorP2.fin(): + # logger.info(f"{ticks_ms()}: P2") + self.__pulsador = 2 + self.__temporizadorP2.iniciar() + + @property + def brillo(self): + return self.__brillo_general + @brillo.setter + def brillo(self, valor:int): + if valor >= 0 and valor <=100: + self.__brillo_general = valor + logger.info(f"El valor de brillo es: {self.__brillo_general}, rango[0-100]") + else: + logger.warning(f"El valor de brillo está fuera de rango: valor={valor}, rango[0-100]") + + @property + def velocidad(self): + return self.__velocidad + @velocidad.setter + def velocidad(self, valor:int): + if valor >= 0 and valor <=1000: + self.__velocidad = valor + logger.info(f"El valor de velocidad es: {self.__velocidad}, rango[0-1000]") + else: + logger.warning(f"El valor de velocidad está fuera de rango: valor={valor}, rango[0-1000]") + + @property + def dificultad(self): + return self.__dificultad + @dificultad.setter + def dificultad(self, valor:int): + if valor >= 1 and valor <=10: + self.__dificultad = valor + logger.info(f"El valor de dificultad es: {self.__dificultad}, rango[1-10]") + else: + logger.warning(f"El valor de dificultad está fuera de rango: valor={valor}, rango[1-10]") + + + async def moverBolaDerecha(self, posiciones:int=1): + __posiciones = posiciones + __casilla_destino = self.__bola.posicion + __posiciones + if __casilla_destino < self.__casillas_totales: # Si estamos dentro del rango + self.__bola.posicion += __posiciones + self.__capa_bola = np.roll(self.__capa_bola, __posiciones * 3) + return True + else: # Nos hemos salido del rango, nos movemos solo hasta el extremo + __posiciones = self.__casillas_totales - self.__bola.posicion - 1 + self.__bola.posicion = self.__casillas_totales-1 + if __posiciones != 0: + self.__capa_bola = np.roll(self.__capa_bola, __posiciones * 3) + + await asyncio.wait_for(self.gol(jugador=1),10) + return False + + async def moverBolaIzquierda(self, posiciones:int=1): + __posiciones = posiciones + __casilla_destino = self.__bola.posicion - __posiciones + if __casilla_destino >= 0: + self.__bola.posicion -= __posiciones + self.__capa_bola = np.roll(self.__capa_bola, -__posiciones * 3) + return True + else: + __posiciones = self.__bola.posicion + self.__bola.posicion = 0 + if __posiciones != 0: + self.__capa_bola = np.roll(self.__capa_bola, -__posiciones * 3) + await asyncio.wait_for(self.gol(jugador=2),10) + return False + + + def mostrarPuntuacion(self): + + self.capa_salida = np.zeros((self.__casillas_totales,3), dtype=np.uint8) + + self.capa_salida[0:self.__puntos_max] = np.array(COLORES[self.color_fondo_puntos], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_fondo_puntos/100) + self.capa_salida[self.__casillas_totales-self.__puntos_max:self.__casillas_totales] = np.array(COLORES[self.color_fondo_puntos], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_fondo_puntos/100) + if self.__puntos_p1>0: + self.capa_salida[0:self.__puntos_p1] = np.array(COLORES[self.color_puntos], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_puntos/100) + # logger.info(f"self.capa_salida[{0}:{self.__puntos_p1}] = np.array({COLORES[self.color_puntos]}, dtype=np.uint8)*{(self.__brillo_general/100)*(self.__brillo_puntos/100)}") + if self.__puntos_p2>0: + self.capa_salida[self.__casillas_totales-self.__puntos_p2:self.__casillas_totales] = np.array(COLORES[self.color_puntos], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_puntos/100) + # logger.info(f"self.capa_salida[{self.__casillas_totales-self.__puntos_p2}:{self.__casillas_totales}] = np.array({COLORES[self.color_puntos]}, dtype=np.uint8)*{(self.__brillo_general/100)*(self.__brillo_puntos/100)}") + self.pintarLeds() + + + + + + def pintarArcoiris(self): + self.__capa_arcoiris = np.zeros((self.__casillas_totales,3), dtype=np.uint8) + self.__capa_porterias = np.zeros((self.__casillas_totales,3), dtype=np.uint8) + casillas_por_color = int(self.__casillas_totales/len(self.__lista_colores_arcoiris)) + casillas_libres = self.__casillas_totales - casillas_por_color * len(self.__lista_colores_arcoiris) + posicion = 0 + for num, color in enumerate(self.__lista_colores_arcoiris): + self.__capa_arcoiris[posicion:posicion+casillas_por_color+casillas_libres] = np.array(COLORES[color], dtype=np.uint8)*(self.__brillo_general/100) + posicion = posicion + casillas_por_color + casillas_libres + if num == 0: + casillas_libres = 0 + self.__capa_porterias = self.__capa_arcoiris + if self.__posicion_arcoiris != 0: + self.__capa_porterias = np.roll(self.__capa_arcoiris, 3*self.__posicion_arcoiris) + self.__posicion_arcoiris += 1 + if self.__posicion_arcoiris >= self.__casillas_totales: + self.__posicion_arcoiris = 0 + + def actualizarPorterias(self): + self.__capa_porterias = np.zeros((self.__casillas_totales,3), dtype=np.uint8) + self.__capa_porterias[0:self.__porteria1.largo] = np.array(COLORES[self.__porteria1.color], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_porterias/100) + self.__capa_porterias[self.__porteria2.posicion:self.__porteria2.posicion+self.__porteria2.largo] = np.array(COLORES[self.__porteria2.color], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_porterias/100) + + async def gol(self, jugador:int, puntos:int=1): + if jugador == 1: + self.__direccion = 0 + self.__puntos_p1 +=1 + # logger.info(f"Jugador {jugador} puntos: {self.__puntos_p1}") + self.reiniciarBola(jugador=2) + + if jugador == 2: + self.__direccion = 0 + self.__puntos_p2 +=1 + # logger.info(f"Jugador {jugador} puntos: {self.__puntos_p1}") + self.reiniciarBola(jugador=1) + + self.__velocidad = self.__tiempoVelocidad.reiniciarVelocidad() + self.desactivarInterrupciones() + self.__bola.ocultar() + logger.info(f"Puntuacion: Jugador 1 tiene {self.__puntos_p1} puntos, jugador 2 tiene {self.__puntos_p2} puntos") + self.mostrarPuntuacion() + await asyncio.sleep(4) + self.activarInterrupciones() + self.__bola.mostrar() + if self.__puntos_p1 >= self.__puntos_max or self.__puntos_p2 >= self.__puntos_max: + self.__puntos_p1, self.__puntos_p2 = 0, 0 + self.__fase="brillo" + self.__bola.ocultar() + self.reiniciarBola(jugador=3) + + + def reiniciarBola(self, jugador): + if jugador == 1: + self.__bola.posicion = self.__porteria1.posicion + elif jugador == 2: + self.__bola.posicion = self.__casillas_totales - 1 + elif jugador == 3: + self.__bola.posicion = int(self.__casillas_totales/2) + self.__capa_bola = np.zeros((self.__casillas_totales,3), dtype=np.uint8) + self.__capa_bola[self.__bola.posicion] = np.array(COLORES[self.__bola.color], dtype=np.uint8)*(self.__brillo_general/100)*(self.__brillo_bola/100) + logger.info(f"Bola reiniciada para {jugador} en la posicion: {self.__bola.posicion}") + + def procesarCapas(self): + self.capa_salida = np.where(self.__capa_bola>self.__capa_porterias, self.__capa_bola, self.__capa_porterias) + self.pintarLeds() + + def pintarLeds(self): + self.__tira_leds.buf = self.capa_salida.tobytes() # Nos saltamos el método __set_item__ y escribimos los colores directamente en formato bytearray + self.desactivarIrqEncoder() + self.__tira_leds.write() + self.activarIrqEncoder() + + def desactivarIrqPulsadores(self): + self.__pin1.irq(trigger=0, handler=None) + self.__pin2.irq(trigger=0, handler=None) + def activarIrqPulsadores(self): + self.__pin1.irq(trigger=machine.Pin.IRQ_FALLING, handler=self.__cbBotonP1) + self.__pin2.irq(trigger=machine.Pin.IRQ_FALLING, handler=self.__cbBotonP2) + + def desactivarIrqEncoder(self): + self.r1._hal_disable_irq() + self.r2._hal_disable_irq() + def activarIrqEncoder(self): + self.r1._hal_enable_irq() + self.r2._hal_enable_irq() + + def desactivarInterrupciones(self): + self.activarIrqPulsadores() + self.desactivarIrqPulsadores() + def activarInterrupciones(self): + self.activarIrqPulsadores() + self.activarIrqEncoder() + + async def seleccionarBrillo(self): + try: + logger.info(f"SELECCIONAR BRILLO") + self.__bola.ocultar() + self.__velocidad = self.__tiempoVelocidad.reiniciarVelocidad() + while self.__fase == "brillo": + self.__velocidad = self.__tiempoVelocidad.cambiosDeVelocidad() + if self.__posiciones_encoder_p1 > 0 or self.__posiciones_encoder_p2 > 0: + self.__brillo_general -= 10 + if self.__brillo_general < 10: + self.__brillo_general = 1 + self.__posiciones_encoder_p1 = 0 + self.__posiciones_encoder_p2 = 0 + elif self.__posiciones_encoder_p1 < 0 or self.__posiciones_encoder_p2 < 0: + self.__brillo_general += 10 + if self.__brillo_general > 100: + self.__brillo_general = 100 + self.__posiciones_encoder_p1 = 0 + self.__posiciones_encoder_p2 = 0 + if self.__pulsador == 1: + self.__empezar_p1 = True + self.__pulsador = 0 + if self.__pulsador == 2: + self.__empezar_p2 = True + self.__pulsador = 0 + if self.__empezar_p1 and self.__empezar_p2 == True: + self.__empezar_p1 = False + self.__empezar_p2 = False + self.__fase = "puntos" + self.pintarArcoiris() + self.procesarCapas() + await asyncio.sleep_ms(self.__velocidad) + except asyncio.TimeoutError: + logger.warning(f"Saliendo de seleccionarBrillo por timeout") + self.__fase="puntos" + except Exception as e: + logger.error(f"Error en seleccionarBrillo: {e}") + + async def seleccionarPuntos(self): + try: + logger.info(f"SELECCIONAR PUNTOS") + self.__velocidad = self.__tiempoVelocidad.reiniciarVelocidad() + while self.__fase == "puntos": + if self.__posiciones_encoder_p1 > 0 or self.__posiciones_encoder_p2 > 0: + self.__puntos_max -= 1 + if self.__puntos_max < 1: + self.__puntos_max = 1 + self.__posiciones_encoder_p1 = 0 + self.__posiciones_encoder_p2 = 0 + elif self.__posiciones_encoder_p1 < 0 or self.__posiciones_encoder_p2 < 0: + self.__puntos_max += 1 + if self.__puntos_max > 24: + self.__puntos_max = 24 + self.__posiciones_encoder_p1 = 0 + self.__posiciones_encoder_p2 = 0 + if self.__pulsador == 1: + self.__empezar_p1 = True + self.__pulsador = 0 + if self.__pulsador == 2: + self.__empezar_p2 = True + self.__pulsador = 0 + if self.__empezar_p1 and self.__empezar_p2 == True: + self.__empezar_p1 = False + self.__empezar_p2 = False + self.__fase = "color" + self.mostrarPuntuacion() + await asyncio.sleep_ms(self.__velocidad) + except asyncio.TimeoutError: + logger.warning(f"Saliendo de seleccionarPuntos por timeout") + self.__fase="color" + except Exception as e: + logger.error(f"Error en seleccionarPuntos: {e}") + + async def seleccionarColor(self): + try: + logger.info(f"SELECCIONAR COLOR") + self.__velocidad = self.__tiempoVelocidad.reiniciarVelocidad() + largo = 10 + direccion = True + largop1 = self.__porteria1.largo + largop2 = self.__porteria2.largo + while self.__fase == "color": + if direccion: + largo += 1 + if largo > int(self.__casillas_totales/2)-2: + direccion = not direccion + else: + largo -= 1 + if largo < 2: + direccion = not direccion + self.__porteria1.largo = largo + self.__porteria2.largo = largo + self.__porteria2.posicion = self.__casillas_totales-largo + + + if self.__posiciones_encoder_p1 > 0: + self.__lista_colores.append(self.__porteria1.color) + self.__porteria1.color = self.__lista_colores.pop(0) + self.__posiciones_encoder_p1 = 0 + elif self.__posiciones_encoder_p1 < 0: + self.__lista_colores.insert(0,self.__porteria1.color) + self.__porteria1.color = self.__lista_colores.pop() + self.__posiciones_encoder_p1 = 0 + + if self.__posiciones_encoder_p2 > 0: + self.__lista_colores.append(self.__porteria2.color) + self.__porteria2.color = self.__lista_colores.pop(0) + self.__posiciones_encoder_p2 = 0 + elif self.__posiciones_encoder_p2 < 0: + self.__lista_colores.insert(0,self.__porteria2.color) + self.__porteria2.color = self.__lista_colores.pop() + self.__posiciones_encoder_p2 = 0 + + if self.__pulsador == 1: + self.__empezar_p1 = True + self.__pulsador = 0 + if self.__pulsador == 2: + self.__empezar_p2 = True + self.__pulsador = 0 + if self.__empezar_p1 and self.__empezar_p2 == True: + self.__empezar_p1 = False + self.__empezar_p2 = False + self.__porteria1.largo = largop1 + self.__porteria2.largo = largop2 + self.__porteria2.posicion = self.__casillas_totales-self.__porteria2.largo + self.__fase = "largo" + + self.actualizarPorterias() + self.procesarCapas() + await asyncio.sleep_ms(self.__velocidad) + + except asyncio.TimeoutError: + logger.warning(f"Saliendo de seleccionarColor por timeout") + self.__fase="largo" + except Exception as e: + logger.error(f"Error en seleccionarColor: {e}") + + async def seleccionarLargo(self): + try: + logger.info(f"SELECCIONAR LARGO") + self.__velocidad = self.__tiempoVelocidad.reiniciarVelocidad() + + while self.__fase == "largo": + + if self.__posiciones_encoder_p1 > 0: + self.__porteria1.largo += 1 + if self.__porteria1.largo > int(self.__casillas_totales/2)-2: + self.__porteria1.largo = int(self.__casillas_totales/2)-2 + self.__posiciones_encoder_p1 = 0 + elif self.__posiciones_encoder_p1 < 0: + self.__porteria1.largo -= 1 + if self.__porteria1.largo < 1: + self.__porteria1.largo = 1 + self.__posiciones_encoder_p1 = 0 + + if self.__posiciones_encoder_p2 > 0: + self.__porteria2.largo += 1 + if self.__porteria2.largo > int(self.__casillas_totales/2)-2: + self.__porteria2.largo = int(self.__casillas_totales/2)-2 + self.__porteria2.posicion = self.__casillas_totales-self.__porteria2.largo + self.__posiciones_encoder_p2 = 0 + elif self.__posiciones_encoder_p2 < 0: + self.__porteria2.largo -= 1 + if self.__porteria2.largo < 1: + self.__porteria2.largo = 1 + self.__porteria2.posicion = self.__casillas_totales-self.__porteria2.largo + self.__posiciones_encoder_p2 = 0 + + if self.__pulsador == 1: + self.__empezar_p1 = True + self.__pulsador = 0 + if self.__pulsador == 2: + self.__empezar_p2 = True + self.__pulsador = 0 + if self.__empezar_p1 and self.__empezar_p2 == True: + self.__empezar_p1 = False + self.__empezar_p2 = False + self.__fase = "inicio" + + self.actualizarPorterias() + self.procesarCapas() + await asyncio.sleep_ms(self.__velocidad) + + except asyncio.TimeoutError: + logger.warning(f"Saliendo de seleccionarLargo por timeout") + self.__fase="inicio" + except Exception as e: + logger.error(f"Error en seleccionarLargo: {e}") + + + async def seleccionarDificultad(self): + try: + logger.info(f"SELECCIONAR DIFICULTAD") + self.__velocidad = self.__tiempoVelocidad.reiniciarVelocidad() + self.__bola.mostrar() + self.reiniciarBola(jugador=3) + while self.__fase == "dificultad": + + if self.__posiciones_encoder_p1 > 0: + self.__dificultad += 1 + if self.__dificultad > 10: + self.__dificultad = 10 + self.__posiciones_encoder_p1 = 0 + elif self.__posiciones_encoder_p1 < 0: + self.__dificultad -= 1 + if self.__dificultad < 1: + self.__dificultad = 1 + self.__posiciones_encoder_p1 = 0 + if self.__posiciones_encoder_p2 > 0: + self.__dificultad += 1 + if self.__dificultad > 10: + self.__dificultad = 10 + self.__posiciones_encoder_p2 = 0 + elif self.__posiciones_encoder_p2 < 0: + self.__dificultad -= 1 + if self.__dificultad < 1: + self.__dificultad = 1 + self.__posiciones_encoder_p2 = 0 + + if self.__pulsador == 1: + self.__empezar_p1 = True + self.__pulsador = 0 + if self.__pulsador == 2: + self.__empezar_p2 = True + self.__pulsador = 0 + if self.__empezar_p1 and self.__empezar_p2 == True: + self.__empezar_p1 = False + self.__empezar_p2 = False + self.__fase = "inicio" + + self.actualizarPorterias() + self.procesarCapas() + await asyncio.sleep_ms(self.__velocidad) + + except asyncio.TimeoutError: + logger.warning(f"Saliendo de seleccionarDificultad por timeout") + self.__fase="inicio" + except Exception as e: + logger.error(f"Error en seleccionarDificultad: {e}") + + + async def inicio(self): + try: + self.__velocidad = self.__tiempoVelocidad.reiniciarVelocidad() + self.__bola.mostrar() + self.reiniciarBola(jugador=3) + logger.info(f"FASE INICIO") + self.actualizarPorterias() + self.procesarCapas() + while self.__fase == "inicio": + if self.__pulsador == 1: + self.__direccion = 2 + self.__pulsador = 0 + self.__fase = "juego" + logger.info(f"FASE JUEGO") + break + if self.__pulsador == 2: + self.__direccion = 1 + self.__pulsador = 0 + self.__fase = "juego" + await asyncio.sleep_ms(self.__velocidad) + except asyncio.TimeoutError: + logger.warning(f"Saliendo de inicio por timeout") + self.__fase="brillo" + except Exception as e: + logger.error(f"Error en inicio: {e}") + + async def juegoPrincipal(self): + try: + logger.info(f"JUEGO PRINCIPAL") + + self.__tiempoVelocidad.iniciarTiempo() + while self.__fase == "juego": + + if self.__pulsador == 1 and self.__bola.posicion <= self.__porteria1.posicion+self.__porteria1.largo-1: + # logger.info(f"self.__pulsador={self.__pulsador}, self.__bola.posicion={self.__bola.posicion}, self.__porteria1.posicion={self.__porteria1.posicion+self.__porteria1.largo}") + self.__direccion = 2 + self.__pulsador = 0 + self.__velocidad = self.__tiempoVelocidad.cambiosDeVelocidad() + if self.__pulsador == 2 and self.__bola.posicion >= self.__porteria2.posicion: + self.__direccion = 1 + self.__pulsador = 0 + self.__velocidad = self.__tiempoVelocidad.cambiosDeVelocidad() + # logger.info(f"self.__pulsador={self.__pulsador}, self.__bola.posicion={self.__bola.posicion}, self.__porteria2.posicion={self.__porteria2.posicion}") + self.__pulsador = 0 + + if self.__direccion == 1: + if not await asyncio.wait_for(self.moverBolaIzquierda(),10): + self.__direccion = 0 + elif self.__direccion == 2: + if not await asyncio.wait_for(self.moverBolaDerecha(),10): + self.__direccion = 0 + else: + pass + self.procesarCapas() + await asyncio.sleep_ms(self.__velocidad) + except asyncio.TimeoutError: + logger.warning(f"Saliendo de juegoPrincipal por timeout") + self.__fase="brillo" + except Exception as e: + logger.error(f"Error en juegoPrincipal: {e}") + +luces = MiTiraDeLeds() +mandos = MisMandos() +temporizador = Temporizador(tiempo_ms=500) \ No newline at end of file