Una guía para principiantes sobre el tablero de pruebas de Raspberry Pi con el juego Simon

Aranzulla de Los Pobres

Una placa le permite crear circuitos sin tener que soldar nada. Es una gran herramienta para experimentar con la electrónica, pero puede resultar intimidante. Tener un proyecto para construir puede ayudarlo a mantenerse motivado mientras aprende.

Hay varios juegos simples que son excelentes proyectos para principiantes de Raspberry Pi. Uno fácil de comenzar es el juego Simon. Simon es un juego de memoria en el que una serie de luces parpadean en orden aleatorio y el jugador debe recordar la secuencia. A medida que el jugador avanza, la duración de la secuencia aumenta.

Componentes requeridos

Para comenzar, necesitará lo siguiente:

  1. Una frambuesa pi
  2. Una tarjeta microSD flasheó con Raspbian OS
  3. 4 x LED de diferentes colores
  4. 4 resistencias (desde 220 ohmios hasta 1 kiloohmio)
  5. 4 x botones
  6. 1 x tablero
  7. Cables de puente para conectar todo

Puede usar cualquier Raspberry Pi para este proyecto, pero los modelos Pi Zero no se conectan a las placas de prueba tan fácilmente sin un poco de soldadura. Independientemente del modelo que utilice, también necesitará una fuente de alimentación, un monitor, un teclado y un mouse.

Si nunca antes ha configurado una Raspberry Pi, puede aprender cómo preparar todo para este tutorial en la guía para principiantes de Raspberry Pi .

Escribirás código Python en este tutorial y puedes usar cualquier editor de texto para escribirlo, pero es posible que te resulte más fácil encontrar un editor de código. Ya hay varios instalados en el sistema operativo Raspberry Pi, y Thonny está diseñado para ser fácil para los principiantes. Cualquiera que sea el que use, deberá poder guardar y ejecutar su código para seguir este tutorial.

Introducción a una placa de pruebas

Si nunca antes ha usado una placa de pruebas, es posible que desee comenzar leyendo un tutorial de placa de pruebas . Comprender cómo funciona una placa de pruebas le ayudará a comprender cómo crear circuitos.

La Raspberry Pi tiene dos filas de pines de entrada / salida de uso general (GPIO). Estos pines le permiten conectar componentes a su Raspberry Pi. Algunos pines envían información, otros proporcionan energía y algunos conectan a tierra sus dispositivos electrónicos.

Comenzaremos agregando una luz LED a nuestra placa de pruebas. Si nunca antes ha trabajado con luces LED en una placa de pruebas, es posible que desee leer un tutorial que explique cómo funciona con más profundidad .

Comience conectando un pin GPIO a su placa. No importa qué pin, siempre que sea un pin GPIO y no un pin de alimentación o de tierra. Arriba hay una tabla de los pines GPIO, que le ayudará a determinar qué pin utilizar. Este tutorial usa el pin número 18, que también está etiquetado como GPIO 24.

El pin proporcionará algo de energía a la placa y permitirá que la Raspberry Pi se comunique con los componentes de la placa. Luego, conecte el pin número 6 en el Pi al riel de tierra de la placa de pruebas. Esto conectará a tierra la placa y nos permitirá crear circuitos.

La potencia que proviene de la Raspberry es demasiado alta para conectar el LED directamente. El uso de una resistencia reduce el nivel de potencia y evita que el LED se apague. Conecte un lado de la resistencia a la misma línea a la que está conectado el pin GPIO y el extremo al otro lado de la placa. Luego coloque el lado positivo del LED después de la resistencia. El extremo negativo del LED se puede conectar directamente al riel negativo. El resultado final debería parecerse al diagrama anterior. Verifique su cableado a fondo y encienda su Pi. El LED debería encenderse.

Ahora, ha creado un circuito con su Raspberry Pi que puede controlar mediante código.

Uso de código Python para controlar los LED

Este tutorial lo lleva a través del código en pasos, pero si desea consultar el código terminado en cualquier momento, está disponible en Pastebin .

En este momento, la energía va al LED, pero queremos controlar cuándo se enciende y se apaga. El siguiente código de Python nos permitirá hablar con el tablero.

 
import RPi.GPIO as GPIO
 GPIO.setmode(GPIO.BOARD)
 GPIO.setwarnings(False)
 red = 18
 GPIO.setup(red, GPIO.OUT)
 GPIO.output(red, GPIO.LOW)

Las primeras líneas configuraron las cosas. Se importa la biblioteca GPIO de Raspberry Pi. Como GPIO solo nos permite referirnos a RPi.GPIO como GPIO para ahorrar un poco de escritura. El modo de pin GPIO se establece en BOARD . No tiene que usar esta configuración, pero puede ser más fácil hacer referencia a los pines por su orden en las filas GPIO.

Finalmente, configuramos las advertencias en falso. Esto detendrá las advertencias innecesarias.

Las siguientes tres líneas controlan el LED. El LED rojo está conectado al pin 18 de GPIO. En lugar de recordarlo, la variable roja almacenará la ubicación. A continuación, GPIO.setup le dice a nuestro programa que se esté enviando información a la clavija roja. Finalmente, configuramos el GPIO. salida en el pin rojo a baja . Cuando ejecute este programa, la luz se apagará. Para volver a encenderlo, cambie GPIO.LOW a GPIO.HIGH y ejecute el programa nuevamente.

Guarde el código y haga clic en ejecutar para verlo en acción. Si no hay un botón de ejecución en su editor de código, guárdelo y ejecute python myfilename.py en la ventana de terminal. Primero deberá navegar al mismo directorio que su nuevo archivo Python. Consulte la hoja de trucos de Raspberry Pi si no está seguro de cómo hacerlo.

Agregar más de un LED

Para crear el juego Simon, necesitamos cuatro luces de diferentes colores. Los mismos pasos que usó para configurar el LED rojo se pueden usar para configurar los otros tres. Su cableado debe verse como el diagrama a continuación:

Tu código debería verse así:

 
import RPi.GPIO as GPIO
 GPIO.setmode(GPIO.BOARD)
 GPIO.setwarnings(False)
 red = 18
 yellow = 22
 green = 24
 blue = 26
 GPIO.setup(red, GPIO.OUT)
 GPIO.setup(yellow, GPIO.OUT)
 GPIO.setup(green, GPIO.OUT)
 GPIO.setup(blue, GPIO.OUT)
 GPIO.output(red, GPIO.HIGH)
 GPIO.output(yellow, GPIO.HIGH)
 GPIO.output(green, GPIO.HIGH)
 GPIO.output(blue, GPIO.HIGH)

Una vez que haya probado los LED, configure GPIO.output en GPIO.LOW para apagar cada uno nuevamente.

Aunque el color de los cables que use no importa, intente usar colores que tengan significado para usted para ayudarlo a leer el tablero más fácilmente. Por ejemplo, los cables negros se utilizan a menudo para cables de tierra. En este circuito, es posible que desee hacer coincidir el color del cable con el color de la luz LED.

Control de LED con botones

Comience agregando un botón a su tablero. El botón deberá estar conectado tanto a tierra como a un pin GPIO. El circuito debería verse así:

Para que el botón controle un LED, debemos agregarlo a nuestro código. Configurar el botón es similar a configurar un LED, excepto que el pin GPIO está configurado para ser una entrada, no una salida. Este código también configura la resistencia pull-up interna en el Pi, que es necesaria para que el botón se comporte correctamente.

 GPIO.setup (32, GPIO.IN, pull_up_down = GPIO.PUD_UP)

Ahora necesitamos un código que verifique si se ha presionado el botón.

 
game = True
 while game:
 redButtonState = GPIO.input(32)
 if redButtonState == 0:
 GPIO.output(red, GPIO.HIGH)
 time.sleep(1)
 GPIO.output(red, GPIO.LOW)

Queremos que nuestro programa siga comprobando si se presiona un botón, por lo que usamos un ciclo while . Debido a que el bucle nunca será falso, sigue ejecutándose y revisando el botón hasta que finalizamos el programa manualmente presionando el botón de parada o usando el atajo de teclado Ctrl + c .

A continuación, para facilitar la referencia a la entrada que nos envía nuestro pin GPIO de botón, guardamos esa información en la variable redButtonState . Si la entrada de nuestro botón cambia a 0, sabemos que se presionó el botón.

Si se presiona el botón, el LED rojo se encenderá. Luego, después de un segundo, el LED se apagará. Para cronometrar esto, usamos la función time.sleep (1) . Para que esto funcione, deberá importar la biblioteca de tiempo en la parte superior de su secuencia de comandos.

Una vez que un botón está funcionando, puede agregar tres más, uno para cada LED. Tu código debería verse así:

 
import random
 import time
 import RPi.GPIO as GPIO
 GPIO.setmode (GPIO.BOARD)
 GPIO.setwarnings(False)
 red = 18
 yellow = 22
 green = 24
 blue = 26
 GPIO.setup(red, GPIO.OUT)
 GPIO.setup(yellow, GPIO.OUT)
 GPIO.setup(green, GPIO.OUT)
 GPIO.setup(blue, GPIO.OUT)
 GPIO.setup(32, GPIO.IN, pull_up_down=GPIO.PUD_UP)
 GPIO.setup(36, GPIO.IN, pull_up_down=GPIO.PUD_UP)
 GPIO.setup(38, GPIO.IN, pull_up_down=GPIO.PUD_UP)
 GPIO.setup(40, GPIO.IN, pull_up_down=GPIO.PUD_UP)
 game = True
 while game:
 redButtonState = GPIO.input(32)
 if redButtonState == 0:
 GPIO.output(red, GPIO.HIGH)
 time.sleep(1)
 GPIO.output(red, GPIO.LOW)

 yellowButtonState = GPIO.input(36)
 if yellowButtonState == 0:
 GPIO.output(yellow, GPIO.HIGH)
 time.sleep(1)
 GPIO.output(yellow, GPIO.LOW)
 greenButtonState = GPIO.input(38)
 if greenButtonState == 0:
 GPIO.output(green, GPIO.HIGH)
 time.sleep(1)
 GPIO.output(green, GPIO.LOW)
 blueButtonState = GPIO.input(40)
 if blueButtonState == 0:
 GPIO.output(blue, GPIO.HIGH)
 time.sleep(1)
 GPIO.output(blue, GPIO.LOW)

Tu tablero debería verse así:

Toda la electrónica está ahora en su lugar. Si tiene algún problema, revise su código en busca de errores. Recuerde, puede descargar el código completo de Pastebin si se queda atascado.

Creando el juego

Este proyecto ya ha cubierto todos los aspectos básicos que necesita saber para comenzar a usar una placa de pruebas. ¡Pero convertir estas habilidades en un juego realmente mostrará lo que puedes hacer!

En Simon, un jugador ve una serie de luces parpadear y tiene que recordar el patrón. Empieza fácilmente con una sola luz. Cada nivel agrega una luz aleatoria al patrón para hacer el juego más difícil.

Creando el Patrón

Este paso es bastante sencillo. Una matriz contendrá nuestro patrón de luz. Una segunda matriz almacenará los pines GPIO para nuestras luces . En cada bucle de juego, se agregará una nueva luz aleatoria al final de la matriz de patrones . Usamos el azar. Función randint () para elegir un número entre 0 y 3, que representa los 4 LED.

 
pattern = []
 lights = [red, yellow, green, blue]
 while game:
 pattern.append(random.randint(0,3))

A continuación, tenemos que encender las luces para mostrar el patrón.

 while game:
 pattern.append(random.randint(0,3))

 for x in pattern:
 GPIO.output(lights[x], GPIO.HIGH)
 time.sleep(1)
 GPIO.output(lights[x], GPIO.LOW)
 time.sleep(0.5)

Es importante hacer una pausa entre dos luces. Hace que sea más fácil ver si se usa la misma luz consecutiva en el patrón.

Obtener la entrada del jugador

A continuación, el juego tiene que esperar a que el jugador adivine el orden de las luces. El programa tiene que verificar cada luz en el patrón y esperar a que el jugador presione un botón. Esto requiere bucles anidados:

 
for x in pattern:

 waitingForInput = True

 while waitingForInput:
 redButtonState = GPIO.input(32)
 yellowButtonState = GPIO.input(36)
 greenButtonState = GPIO.input(38)
 blueButtonState = GPIO.input(40)

 if redButtonState == 0:
 GPIO.output(red, GPIO.HIGH)
 waitingForInput = False
 time.sleep(1)
 GPIO.output(red, GPIO.LOW)

 if yellowButtonState == 0:
 GPIO.output(yellow, GPIO.HIGH)
 waitingForInput = False
 time.sleep(1)
 GPIO.output(yellow, GPIO.LOW)

 if greenButtonState == 0:
 GPIO.output(green, GPIO.HIGH)
 waitingForInput = False
 time.sleep(1)
 GPIO.output(green, GPIO.LOW)

 if blueButtonState == 0:
 GPIO.output(blue, GPIO.HIGH)
 waitingForInput = False
 time.sleep(1)
 GPIO.output(blue, GPIO.LOW)

La mayor parte del código anterior está reutilizando el código que escribimos para probar los botones.

Relacionado: 6 razones por las que Python es el lenguaje de programación del futuro

Verifique la entrada del jugador

A partir de aquí, es bastante fácil comprobar si el jugador ha introducido el patrón correcto. Cada vez que presionan un botón, el juego puede verificar si ese era el botón correcto. Para hacer esto, agregue otra instrucción if a cada entrada de botón:

 
if redButtonState == 0:
 GPIO.output(red, GPIO.HIGH)
 waitingForInput = False
 if x != 0:
 game = False
 time.sleep(1)
 GPIO.output(red, GPIO.LOW)

La variable x de nuestro bucle for tiene el número de la siguiente luz. La luz LED roja está en la primera posición, o el número 0. Si el jugador presionó el botón LED rojo cuando tenemos un 0 en nuestro patrón, ¡tiene razón! Si no, pierden el juego. Establecer la variable juego en falso detendrá nuestro ciclo de juego y finalizará el programa.

¡Felicidades! ¡Construiste un juego desde cero!

La creación de un juego agregó mucho más código a este proyecto que solo agregar LED y botones. Trabajar hacia un proyecto final que pueda mostrar a sus amigos y familiares puede ayudarlo a mantenerse motivado.

Este juego es bastante simple. Ponte a prueba para mejorar el diseño básico. Quizás las luces podrían parpadear si el jugador pierde. Tal vez quieras desafiarte a ti mismo para agregar sonidos al juego. ¡Tú imaginación es el único límite!

Bien, eso y el hardware que tienes a mano.