Construir a ponte interativa do Rainbow usando o Minecraft Raspberry Pi Edition: 11 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Ontem, eu vi meu sobrinho de 8 anos jogando Minecraft com o Raspberry Pi que eu dei a ele antes, então eu tive uma ideia, que é usar código para fazer um projeto de blocos de LED do Minecraft-pi personalizado e emocionante. Minecraft Pi é uma ótima maneira de começar com o microcomputador Raspberry Pi, o Minecraft Pi é uma versão especial do Minecraft que nos permite interagir com o jogo usando uma API Python simples mortal para personalizar a experiência do jogo e adereços!

Existem muitos projetos que você pode fazer no mundo do Minecraft com o Raspberry Pi, mas especificamente para nós não era o suficiente, estávamos procurando por algo desafiador e piscando ao mesmo tempo. Neste projeto, vamos pisar em vários blocos do Minecraft, detectar o ID do bloco e detectar a cor do bloco específico em que pisamos, com base na cor que acenderemos nosso LED RGB para criar um jogo de etapas interativo!

Vou usar dois métodos para conseguir o efeito, o primeiro é usar os acessórios, que podem ser muito caóticos…; a segunda é usar CrowPi2 (computador de aprendizagem com muitos sensores, atualmente financiado por crowdfunding no Kickstarter: CrowPi2)

vamos começar e ver como arquivar um projeto tão incrível!

Suprimentos

O CrowPi2 agora está ao vivo no kickstarter. O projeto CrowPi2 arrecadou quase $ 250k.

Clique no link:

Método 1 usando acessórios

Etapa 1: Materiais

● 1 x Raspberry Pi 4 modelo B

● 1 x cartão TF com imagem

● 1 fonte de alimentação Raspberry Pi

● Monitor de 1 x 10,1 polegadas

● 1 x fonte de alimentação para monitor

● 1 cabo HDMI

● 1 x teclado e mouse

● 1 x LED RGB (cátodo comum)

● 4 x jumpers (feminino para feminino)

Etapa 2: Diagrama de conexão

Na verdade, existem três luzes no LED de cor RGB, que são luz vermelha, luz verde e luz azul. Controle essas três luzes para emitir luz de intensidades diferentes e, quando misturadas, podem emitir luz de várias cores. Os quatro pinos da luz LED são GND, R, G e B, respectivamente. O LED RGB que usei é um cátodo comum e a conexão com o Raspberry Pi é a seguinte:

RaspberryPi 4B (no nome da função) LED RGB

GPIO0 1 RED

GPIO1 3 VERDE

GPIO2 4 AZUL

GND 2 GND

A segunda imagem é a conexão de hardware

Etapa 3: Configurar para SPI

Como precisamos usar o SPI para controlar o RGB, precisamos primeiro habilitar a interface SPI, que é desabilitada por padrão. Você pode seguir as etapas abaixo para habilitar a interface SPI:

Primeiro, você pode usar a GUI da área de trabalho acessando MenupreferencesRaspberry Pi Configuration do Pi start, como mostrado na primeira imagem.

Em segundo lugar, navegue até “Interfaces” e ative o SPI e clique em OK (a segunda imagem).

Por último, reinicie seu Pi para garantir que as alterações tenham efeito. Clique em Pi Start MenuPreferencesShutdown. Uma vez que só precisamos reiniciar, clique no botão Reiniciar.

Etapa 4: O Código

Começaremos escrevendo nosso código Python, primeiro, começaremos importando algumas bibliotecas que precisaremos para integrar nosso código ao mundo do Minecraft. Em seguida, importaremos a biblioteca de tempo, especificamente uma função chamada sleep. A função dormir nos permitirá esperar um intervalo específico antes de realizar uma função. Por último, mas não menos importante, importamos a biblioteca RPi. GPIO, que nos permite controlar o GPIO no Raspberry Pi.

from mcpi.minecraft import Minecraft from time import sleep import RPi. GPIO as GPIO

E é isso, terminamos a importação das bibliotecas, agora é hora de usá-las! A primeira coisa é usar a biblioteca do Minecraft, queremos conectar nosso script python ao mundo do Minecraft, podemos fazer isso invocando a função init () da biblioteca MCPI e, em seguida, definir o modo de GPIO e desativar o aviso.

mc = Minecraft.create () GPIO.setmode (GPIO. BCM) GPIO.setwarnings (0)

Agora, definimos algumas cores do arco-íris em hexadecimal para que possamos alterar as cores RGB.

WHITE = 0xFFFFFF RED = 0xFF0000 ORANGE = 0xFF7F00 YELLOW = 0xFFFF00 GREEN = 0x00FF00 CYAN = 0x00FFFF BLUE = 0x0000FF PURPLE = 0xFF00FF MAGENTA = 0xFF0090

Em seguida, precisamos definir algumas variáveis para registrar a cor do bloco de lã, que já está definida na lista de blocos do Minecraft.

W_WHITE = 0 W_RED = 14 W_ORANGE = 1 W_YELLOW = 4 W_GREEN = 5 W_CYAN = 9 W_BLUE = 11 W_PURPLE = 10 W_MAGENTA = 2

O ID do bloco de lã no Minecraft é 35. Agora, precisamos configurar o pino para o led RGB e configurar para eles.

red_pin = 17 green_pin = 18 blue_pin = 27

GPIO.setup (red_pin, GPIO. OUT, initial = 1) GPIO.setup (green_pin, GPIO. OUT, initial = 1) GPIO.setup (blue_pin, GPIO. OUT, initial = 1)

Em seguida, configure o PWM para cada pino, observe que o intervalo do valor de PWM é 0-100. Aqui, definimos primeiro a cor do led RGB para branco (100, 100, 100).

vermelho = GPIO. PWM (red_pin, 100)

green = GPIO. PWM (green_pin, 100) blue = GPIO. PWM (blue_pin, 100) red.start (100) green.start (100) blue.start (100)

A seguir é criar duas funções, que podem ser usadas para decodificar a cor e iluminar o led RGB! Observe que a função map2hundred () é mapear valores de 255 a 100, como dissemos antes, o valor PWM deve ser 0-100.

def map2hundred (valor): return int (valor * 100/255)

def set_color (color_code): # Decodificar red_value = color_code >> 16 & 0xFF green_value = color_code >> 8 & 0xFF blue_value = color_code >> 0 & 0xFF

# Map values red_value = map2hundred (red_value) green_value = map2hundred (green_value) blue_value = map2hundred (blue_value)

# Ilumine! red. ChangeDutyCycle (red_value) green. ChangeDutyCycle (green_value) blue. ChangeDutyCycle (blue_value)

Bem feito! É hora de iniciar nosso programa principal, espere, outra variável deve ser definida para registrar o código de cor do bloco de lã antes do programa principal:

last_data = 0 try: x, y, z = mc.player.getPos () mc.setBlocks (x, y, z, x + 1, y, z + 2, 35, 14) mc.setBlocks (x + 2, y + 1, z, x + 3, y + 1, z + 2, 35, 11) mc.setBlocks (x + 4, y + 2, z, x + 5, y + 2, z + 2, 35, 2) mc.setBlocks (x + 6, y + 3, z, x + 7, y + 3, z + 2, 35, 5) mc.setBlocks (x + 8, y + 4, z, x + 9, y + 4, z + 2, 35, 4) mc.setBlocks (x + 10, y + 5, z, x + 11, y + 5, z + 2, 35, 10) mc.setBlocks (x + 12, y + 6, z, x + 13, y + 6, z + 2, 35, 1) mc.setBlocks (x + 14, y + 5, z, x + 15, y + 5, z + 2, 35, 10) mc.setBlocks (x + 16, y + 4, z, x + 17, y + 4, z + 2, 35, 4) mc.setBlocks (x + 18, y + 3, z, x + 19, y + 3, z + 2, 35, 5) mc.setBlocks (x + 20, y + 2, z, x + 21, y + 2, z + 2, 35, 2) mc.setBlocks (x + 22, y + 1, z, x + 23, y + 1, z + 2, 35, 11) mc.setBlocks (x + 24, y, z, x + 25, y, z + 2, 35, 14) enquanto Verdadeiro: x, y, z = mc.player.getPos () # posição do jogador (x, y, z) bloco = mc.getBlockWithData (x, y-1, z) # ID do bloco #print (bloco) se block.id == WOOL e last_data! = Block.data: if block.data == W_RED: print ("Red!") Set_color (RED) if block.data == W_ORANGE: print ("Orange!") Set_color (ORANGE) if block.data == W_ YELLOW: print ("Yellow!") Set_color (YELLOW) if block.data == W_GREEN: print ("Green!") Set_color (GREEN) if block.data == W_CYAN: print ("Cyan!") Set_color (CYAN) if block.data == W_BLUE: print ("Blue!") set_color (BLUE) if block.data == W_PURPLE: print ("Purple!") set_color (PURPLE) if block.data == W_MAGENTA: print (" Magenta! ") Set_color (MAGENTA) if block.data == W_WHITE: print (" White! ") Set_color (WHITE) last_data = block.data sleep (0.05) exceto KeyboardInterrupt: pass GPIO.cleanup ()

Como o programa principal é mostrado acima, primeiro para usar alguns comandos para gerar alguns blocos de lã coloridos, então precisamos descobrir a posição do jogador para que possamos obter o id dos blocos e seu código de cor. Depois de obter as informações do bloco, usaremos a instrução para determinar se o bloco sob o jogador é um bloco de lã e se possui o código de cor. Se sim, julgue a cor do bloco de lã e chame a função set_color () para alterar a cor do led RGB da mesma forma que o bloco de lã.

Além disso, adicionamos uma instrução try / except para capturar a exceção da interrupção do usuário quando queremos sair do programa para limpar a saída dos pinos GPIO.

Em anexo está o código completo.

Muito bem, tantos acessórios e complicados demais né? Não se preocupe, vamos ver o segundo método para realizar o projeto, que o deixará mais flexível e cômodo, que é usar nosso CrowPi2!

Etapa 5: o resultado

Abra o jogo e rode o script, você verá o resultado no vídeo acima

Em seguida, usaremos CrowPi2 para construir a ponte interativa do arco-íris a seguir

Etapa 6: usando materiais CrowPi2

● 1 x CrowPi2

Etapa 7: Usando CrowPi2- Diagrama de Conexão

Não há necessidade. Existem muitos sensores e componentes úteis (mais de 20) no CrowPi2, tudo em um laptop raspberry pi e plataforma de educação STEM que nos permite fazer vários projetos com facilidade e sem esforço! Neste caso, usaremos um módulo atraente e colorido no CrowPi2, que é um módulo de matriz 8x8 RGB, que nos permite controlar 64 led RGB ao mesmo tempo!

Etapa 8: Usando CrowPi2- Configurar para SPI

Não há necessidade. CrowPi2 vem com uma imagem embutida com um sistema de aprendizagem! Tudo foi preparado, o que significa que você pode programar e aprender diretamente. Além disso, com o nosso CrowPi2 é fácil e já integrado na placa como uma plataforma STEAM pronta para usar.

Etapa 9: Usando CrowPi2- o Código

Agora é hora de começar nosso programa! Primeiro, importe algumas bibliotecas, como a biblioteca MCPI que é a biblioteca Minecraft Pi Python que nos permite usar uma API muito simples para integração com o mundo do Minecraft; biblioteca de tempo que nos permite a função dormir para esperar um intervalo específico antes de realizar uma função; Biblioteca RPi. GPIO que nos permite controlar os pinos GPIO do Raspberry Pi.

from mcpi.minecraft import Minecraft from time import sleep import RPi. GPIO as GPIO

Por fim, importaremos uma biblioteca chamada rpi_ws281x que é a biblioteca RGB Matrix, dentro da biblioteca, existem várias funções que usaremos, como PixelStrip para configurar o objeto de faixa de LED e Color para configurar um objeto de cor RGB para acender nossos LEDs RGB

de rpi_ws281x import PixelStrip, Color

E é isso, terminamos a importação das bibliotecas, agora é hora de usá-las! Da mesma forma, a primeira coisa é usar a biblioteca do Minecraft, queremos conectar nosso script python ao mundo do Minecraft, podemos fazer isso invocando a função init da biblioteca MCPI:

mc = Minecraft.create ()

Agora, toda vez que quisermos realizar operações no mundo minecrat, podemos usar o objeto mc.

O próximo passo será definir a classe de matriz de LED RGB que usaremos para controlar nossos LEDs RGB, inicializamos a classe com configuração básica, como número de leds, pinos, brilho etc …

nós criamos uma função chamada clean que irá “limpar” menos com a cor específica dada e também uma função chamada run que irá inicializar o objeto LED RGB real na primeira vez que quisermos usá-lo.

classe RGB_Matrix:

def _init _ (self):

# Configuração da faixa de LED:

self. LED_COUNT = 64 # Número de pixels de LED.

self. LED_PIN = 12 # pino GPIO conectado aos pixels (18 usa PWM!).

self. LED_FREQ_HZ = 800000 # frequência do sinal LED em hertz (geralmente 800 khz)

self. LED_DMA = 10 # canal DMA para usar para gerar sinal (tente 10)

self. LED_BRIGHTNESS = 10 # Defina como 0 para o mais escuro e 255 para o mais claro

self. LED_INVERT = False # True para inverter o sinal

self. LED_CHANNEL = 0 # definido como '1' para GPIOs 13, 19, 41, 45 ou 53

# Definir funções que animam LEDs de várias maneiras. def clean (self, strip, color):

# limpe todos os LEDs de uma vez

para i no intervalo (strip.numPixels ()):

strip.setPixelColor (i, color)

strip.show ()

def run (self):

# Crie um objeto NeoPixel com a configuração apropriada.

strip = PixelStrip (self. LED_COUNT, self. LED_PIN, self. LED_FREQ_HZ, self. LED_DMA, self. LED_INVERT, self. LED_BRIGHTNESS, self. LED_CHANNEL)

Experimente:

tira de retorno

exceto KeyboardInterrupt:

# limpe o LED da matriz antes da interrupção

self.clean (tira)

Depois de terminarmos com o acima, é hora de invocar essas classes e criar objetos que podemos usar em nosso código, primeiro vamos criar um objeto de matriz RGB LED que podemos usar usando a classe que criamos anteriormente:

matrixObject = RGB_Matrix ()

Agora vamos usar este objeto para criar um objeto de faixa de LED ativo que usaremos para controlar nossos LEDs individuais na matriz RGB:

strip = matrixObject.run ()

Finalmente, para ativar esta faixa, precisamos executar uma última função:

strip.begin ()

A API do Minecraft inclui muitos blocos, cada bloco do Minecraft tem seu próprio ID. Em nosso exemplo, pegamos uma quantidade de blocos do Minecraft e tentamos adivinhar qual cor é mais adequada para eles.

RGB significa vermelho, verde e azul, então precisaremos de 3 valores diferentes, variando de 0 a 255 para cada um, as cores podem ser no formato HEX ou RGB, estamos usando o formato RGB como nosso exemplo.

No mundo do Minecraft Pi existem IDs de blocos normais e IDs de blocos de lã especiais, a lã especial vem com o número de ID 35, mas com subnúmeros variando de muitos IDs diferentes … Vamos resolver este problema criando 2 listas separadas, uma para blocos normais e uma lista para blocos de lã especiais:

A primeira lista é para blocos normais, por exemplo 0 representa bloco de ar, vamos definir a cor 0, 0, 0 que é em branco ou branco completo, quando o jogador vai pular ou voar no jogo o RGB será desligado, 1 é um bloco diferente com cores RGB 128, 128, 128 e assim por diante …

#Rainbow Colors

rainbow_colors = {

"0": Cor (0, 0, 0), "1": Cor (128, 128, 128), "2": Cor (0, 255, 0), "3": Cor (160, 82, 45), "4": Cor (128, 128, 128), "22": Cor (0, 0, 255)

}

Para os blocos de lã fazemos o mesmo, mas é importante lembrar que todos os blocos têm um ID de 35, nesta lista definimos os subtipos do bloco que é o bloco de lã. Diferentes subtipos de lã têm cores diferentes, mas todos eles são blocos de lã.

lã_colors = {

"6": Cor (255, 105, 180), "5": Cor (0, 255, 0), "4": Cor (255, 255, 0), "14": Cor (255, 0, 0), "2": Cor (255, 0, 255)

}

Agora, quando terminamos de definir nosso programa principal, classes e funções, é hora de integrar com nosso sensor CrowPi2 RGB LED integrado.

O programa principal pegará os parâmetros que definimos anteriormente e colocará o impacto no hardware.

Vamos usar o LED RGB CrowPi2 para iluminá-los com base nas etapas que fazemos dentro do Minecraft Pi em cada bloco, vamos começar!

A primeira coisa que faremos é gerar alguns blocos de lã com comandos e criar um loop while, para manter o programa em execução enquanto jogarmos o jogo.

Precisamos obter alguns dados do jogador, primeiro usamos o comando player.getPos () para obter a posição do jogador, em seguida, usamos getBlockWithData () para obter o bloco em que estamos atualmente (coordenada y é -1, que significa sob o jogador)

x, y, z = mc.player.getPos ()

mc.setBlocks (x, y, z, x + 1, y, z + 2, 35, 14)

mc.setBlocks (x + 2, y + 1, z, x + 3, y + 1, z + 2, 35, 11)

mc.setBlocks (x + 4, y + 2, z, x + 5, y + 2, z + 2, 35, 2)

mc.setBlocks (x + 6, y + 3, z, x + 7, y + 3, z + 2, 35, 5)

mc.setBlocks (x + 8, y + 4, z, x + 9, y + 4, z + 2, 35, 4)

mc.setBlocks (x + 10, y + 5, z, x + 11, y + 5, z + 2, 35, 10)

mc.setBlocks (x + 12, y + 6, z, x + 13, y + 6, z + 2, 35, 1)

mc.setBlocks (x + 14, y + 5, z, x + 15, y + 5, z + 2, 35, 10)

mc.setBlocks (x + 16, y + 4, z, x + 17, y + 4, z + 2, 35, 4)

mc.setBlocks (x + 18, y + 3, z, x + 19, y + 3, z + 2, 35, 5)

mc.setBlocks (x + 20, y + 2, z, x + 21, y + 2, z + 2, 35, 2)

mc.setBlocks (x + 22, y + 1, z, x + 23, y + 1, z + 2, 35, 11)

mc.setBlocks (x + 24, y, z, x + 25, y, z + 2, 35, 14)

enquanto verdadeiro:

x, y, z = mc.player.getPos () # posição do jogador (x, y, z)

blockType, data = mc.getBlockWithData (x, y-1, z) # ID do bloco

imprimir (blockType)

Em seguida, vamos verificar se o bloco é um bloco de lã, bloco ID número 35, se for, vamos nos referir a lã_colors com a cor do bloco com base no ID do dicionário e iluminar a cor certa de acordo.

if blockType == 35:

# cores de lã personalizadas

matrixObject.clean (strip, wool_colors [str (data)])

Se não for um bloco de lã, vamos verificar se o bloco está dentro do dicionário rainbow_colors para evitar exceções; se estiver, continuaremos pegando a cor e alterando o RGB.

if str (blockType) em rainbow_colors:

imprimir (rainbow_colors [str (blockType)])

matrixObject.clean (strip, rainbow_colors [str (blockType)])

dormir (0,5)

Você sempre pode tentar adicionar mais blocos ao rainbow_color para adicionar mais cores e mais blocos de suporte!

Perfeito! Fazer projetos usando acessórios é complicado, mas usando o circuito integrado CrowPi2, as coisas ficam muito mais fáceis! Além do mais, existem mais de 20 sensores e componentes no CrowPi2, o que permite que você alcance seus projetos ideais e até mesmo projetos de IA!

Abaixo está o código completo:

Etapa 10: Usando CrowPi2-the Result

Abra o jogo e execute o script, você verá o resultado no vídeo acima:

Etapa 11: Uso do CrowPi2 - Indo além

Agora terminamos nosso projeto colorido no jogo Minecraft com CrowPi2. Por que não tentar usar outros sensores e componentes no CrowPi2 para jogar com o jogo, como joystick para controlar o movimento do jogador, RFID para gerar blocos com base em diferentes cartões NFC e etc. Divirta-se com seu jogo no CrowPi2 e espero que consiga fazer mais projetos incríveis com CrowPi2!

Agora que o CrowPi2 está no Kickstarter, você também pode aproveitar o preço atraente.

Anexe o link da página do Kickstarter CrowPi2