Cargamos contenido del curos + Practica 01

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

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

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

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!
+"""
+

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)

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!
+"""
+
+

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")
+
+
+
+
+

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
+
+"""
+

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
+
+
+

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
+"""

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
+                
+"""

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

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
+    
+
+    

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

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.

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

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