Um guia para iniciantes em relação ao Raspberry Pi Breadboarding com o jogo Simon

gurinho

Uma placa de ensaio permite que você crie circuitos sem precisar soldar nada. É uma ótima ferramenta para fazer experiências com eletrônicos, mas pode ser intimidante. Ter um projeto para construir pode ajudá-lo a se manter motivado enquanto aprende.

Existem vários jogos simples que são ótimos projetos para iniciantes no Raspberry Pi. Um jogo fácil para você começar é o jogo Simon. Simon é um jogo de memória em que uma série de luzes piscam em ordem aleatória e o jogador deve se lembrar da sequência. Conforme o jogador avança, a duração da sequência aumenta.

Componentes Requeridos

Para começar, você precisará do seguinte:

  1. Um Raspberry Pi
  2. Um cartão microSD piscou com Raspbian OS
  3. 4 x LEDs de cores diferentes
  4. 4 x resistores (qualquer coisa de 220 Ohm a 1 Kilo-Ohm)
  5. 4 botões x
  6. 1 placa de ensaio
  7. Cabos jumper para conectar tudo

Você pode usar qualquer Raspberry Pi para este projeto, mas os modelos Pi Zero não se conectam a placas de ensaio tão facilmente sem um pouco de solda. Qualquer que seja o modelo usado, você também precisará de uma fonte de alimentação, monitor, teclado e mouse.

Se você nunca configurou um Raspberry Pi antes, pode aprender como deixar tudo pronto para este tutorial no guia do iniciante do Raspberry Pi .

Você escreverá código Python neste tutorial e pode usar qualquer editor de texto para escrevê-lo, mas pode achar um editor de código mais fácil. Existem vários já instalados no Raspberry Pi OS, e Thonny foi projetado para ser fácil para iniciantes. Qualquer que você usar, será necessário salvar e executar seu código para seguir este tutorial.

Primeiros passos com um breadboard

Se você nunca usou um protoboard antes, pode começar lendo um tutorial do protoboard . Entender como funciona uma placa de ensaio ajudará você a entender como criar circuitos.

O Raspberry Pi tem duas linhas de pinos de entrada / saída de uso geral (GPIO). Esses pinos permitem conectar componentes ao Raspberry Pi. Alguns pinos enviam informações, outros fornecem energia e alguns aterram seus componentes eletrônicos.

Começaremos adicionando uma luz LED à nossa placa de ensaio. Se você nunca trabalhou com luzes LED em uma placa de ensaio antes, talvez queira ler um tutorial que explicará como funciona com mais detalhes .

Comece conectando um pino GPIO à sua placa. Não importa qual pino, contanto que seja um pino GPIO e não um pino de alimentação ou aterramento. Acima está um gráfico dos pinos GPIO, que o ajudará a determinar qual pino usar. Este tutorial usa o pino número 18, também denominado GPIO 24.

O pino fornecerá alguma energia para a placa de ensaio e permitirá que o Raspberry Pi se comunique com os componentes da placa. Em seguida, conecte o pino número 6 no Pi ao trilho de aterramento da placa de ensaio. Isso irá aterrar a placa e nos permitir criar circuitos.

A energia que vem do Raspberry é muito alta para conectar o LED diretamente. O uso de um resistor reduz o nível de energia e evita que o LED queime. Conecte um lado do resistor à mesma linha em que o pino GPIO está conectado e a extremidade no outro lado da placa de ensaio. Em seguida, coloque o lado positivo do LED após o resistor. A extremidade negativa do LED pode ser conectada diretamente ao trilho negativo. O resultado final deve ser semelhante ao diagrama acima. Verifique sua fiação cuidadosamente e ligue o Pi. O LED deve acender.

Agora, você fez um circuito usando seu Raspberry Pi que pode controlar usando um código.

Usando código Python para controlar LEDs

Este tutorial o conduz através do código em etapas, mas se você quiser consultar o código concluído a qualquer momento, ele está disponível no Pastebin .

No momento, a energia está indo para o LED, mas queremos controlar quando ele liga e desliga. O código Python a seguir nos permitirá conversar com o conselho.

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

As primeiras linhas definem as coisas. A biblioteca Raspberry Pi GPIO é importada. O as GPIO apenas nos permite nos referir a RPi.GPIO como GPIO para economizar um pouco de digitação. O modo de pino GPIO é definido como BOARD . Você não precisa usar essa configuração, mas pode ser mais fácil referir-se aos pinos por sua ordem nas linhas GPIO.

Por fim, definimos os avisos como falsos. Isso interromperá os avisos desnecessários.

As próximas três linhas controlam o LED. O LED vermelho está conectado ao pino 18 do GPIO. Em vez de se lembrar disso, a variável red armazenará a localização. Em seguida, GPIO.setup diz nosso programa que está enviando informações para o pino vermelho. Finalmente, definimos o GPIO. saída no pino vermelho para baixo . Quando você executa este programa, a luz se apaga. Para ligá-lo novamente, alterne GPIO.LOW para GPIO.HIGH e execute o programa novamente.

Salve o código e clique em executar para vê-lo em ação. Se não houver um botão de execução em seu editor de código, salve-o e execute python myfilename.py na janela do terminal. Você precisará navegar para o mesmo diretório do seu novo arquivo Python primeiro. Verifique a folha de referências do Raspberry Pi se não tiver certeza de como.

Adicionando mais de um LED

Para criar o jogo Simon, precisamos de quatro luzes de cores diferentes. As mesmas etapas que você usou para configurar o LED vermelho podem ser usadas para configurar os outros três. Sua fiação deve ser semelhante ao diagrama abaixo:

Seu código deve ser assim:

 
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)

Depois de testar os LEDs, defina GPIO.output como GPIO.LOW para desligar cada um novamente.

Embora a cor dos fios que você usa não importe, tente usar cores que tenham um significado para você para ajudá-lo a ler a placa mais facilmente. Por exemplo, fios pretos são freqüentemente usados ​​para fios terra. Neste circuito, você pode querer combinar a cor do fio com a cor da luz LED.

Controle de LEDs com botões

Comece adicionando um botão ao seu quadro. O botão precisará ser conectado ao aterramento e a um pino GPIO. O circuito deve ser semelhante a este:

Para fazer com que o botão controle um LED, precisamos adicionar ao nosso código. Configurar o botão é semelhante a configurar um LED, exceto que o pino GPIO é configurado para ser uma entrada, não uma saída. Este código também configura o resistor pull-up interno no Pi, que é necessário para fazer o botão se comportar corretamente.

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

Agora precisamos de um código que verifique se o botão foi pressionado.

 
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 nosso programa continue verificando se um botão foi pressionado, então usamos um loop while . Como o loop nunca será falso, ele continua executando e verificando o botão até terminarmos o programa manualmente, pressionando o botão parar ou usando o atalho de teclado Ctrl + c .

A seguir, para tornar mais fácil referenciar a entrada que nosso pino GPIO do botão está nos enviando, salvamos essa informação na variável redButtonState . Se a entrada do nosso botão mudar para 0, sabemos que o botão foi pressionado.

Se o botão for pressionado, o LED vermelho acenderá. Então, após um segundo, o LED apagará. Para cronometrar isso, usamos a função time.sleep (1) . Para fazer isso funcionar, você precisará importar a biblioteca de tempo no topo do seu script.

Quando um botão estiver funcionando, você pode adicionar mais três, um para cada LED. Seu código deve ser assim:

 
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)

Seu quadro deve ser semelhante a este:

Todos os componentes eletrônicos estão instalados. Se você tiver qualquer problema, verifique se há erros em seu código. Lembre-se, você pode baixar o código completo do Pastebin se tiver dúvidas!

Criando o Jogo

Este projeto já cobriu todos os fundamentos que você precisa saber para começar a usar uma placa de ensaio. Mas transformar essas habilidades em um jogo realmente mostrará o que você pode fazer!

No Simon, o jogador vê uma série de luzes piscando e precisa se lembrar do padrão. Ele começa facilmente com apenas uma luz. Cada nível adiciona uma luz aleatória ao padrão para tornar o jogo mais difícil.

Criando o padrão

Esta etapa é bastante simples. Uma matriz manterá nosso padrão de luz. Uma segunda matriz armazenará os pinos GPIO para nossas luzes . A cada loop de jogo, uma nova luz aleatória será adicionada ao final do array de padrões . Usamos o aleatório. função randint () para escolher um número entre 0 e 3, representando os 4 LEDs.

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

Em seguida, temos que acender as luzes para mostrar o padrão.

 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)

É importante fazer uma pausa entre duas luzes. Isso torna mais fácil ver se a mesma luz é usada consecutivamente no padrão.

Obtendo a opinião do jogador

Em seguida, o jogo deve esperar que o jogador adivinhe a ordem das luzes. O programa deve verificar cada luz no padrão e esperar que o jogador pressione um botão. Isso requer loops aninhados:

 
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)

A maior parte do código acima está reutilizando o código que escrevemos para testar os botões.

Relacionado: 6 razões pelas quais Python é a linguagem de programação do futuro

Verifique a entrada do jogador

A partir daqui, é muito fácil verificar se o jogador inseriu o padrão correto. Cada vez que pressionam um botão, o jogo pode verificar se esse era o botão correto. Para fazer isso, adicione outra instrução if a cada entrada de botão:

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

A variável x de nosso loop for tem o número da próxima luz. O LED vermelho está na primeira posição, ou número 0. Se o jogador pressionou o botão LED vermelho quando temos um 0 em nosso padrão, ele está certo! Se não, eles perdem o jogo. Definir a variável game como false interromperá nosso loop de jogo e encerrará o programa.

Parabéns! Você construiu um jogo do zero!

Criar um jogo adicionou muito mais código a este projeto do que apenas adicionar LEDs e botões. Trabalhar em um projeto final que você possa mostrar aos seus amigos e familiares pode ajudar a mantê-lo motivado.

Este jogo é bastante simples. Desafie-se a melhorar o design básico. Talvez as luzes possam piscar se o jogador perder. Talvez você queira se desafiar a adicionar sons ao jogo. Sua imaginação é o único limite!

Ok, isso e o hardware que você tem em mãos.