Costruisci Rainbow Interactive Bridge usando Minecraft Raspberry Pi Edition: 11 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Ieri, ho visto mio nipote di 8 anni giocare a Minecraft con il Raspberry Pi che gli avevo dato prima, poi ho avuto un'idea, ovvero usare il codice per creare un progetto di blocchi LED Minecraft-pi personalizzato ed emozionante. Minecraft Pi è un ottimo modo per iniziare con il microcomputer Raspberry Pi, Minecraft Pi è una versione speciale su misura di Minecraft che ci consente di interagire con il gioco utilizzando una letale API Python per personalizzare l'esperienza di gioco e gli oggetti di scena!

Ci sono molti progetti che puoi realizzare nel mondo di Minecraft con il Raspberry Pi ma nello specifico per noi non era abbastanza, stavamo cercando qualcosa di impegnativo e lampeggiante allo stesso tempo. In questo progetto, calpesteremo più blocchi Minecraft, rileveremo l'ID del blocco e rileveremo il colore del blocco specifico su cui abbiamo calpestato, in base al colore illumineremo il nostro LED RGB per creare un gioco interattivo di passaggi!

Userò due metodi per ottenere l'effetto, il primo è usare gli accessori, che possono essere molto caotici…; il secondo sta usando CrowPi2 (computer di apprendimento con molti sensori, attualmente finanziato in crowdfunding su Kickstarter: CrowPi2)

iniziamo e vediamo come archiviare un progetto così straordinario!

Forniture

Il CrowPi2 ora è attivo sul kickstarter ora, il progetto CrowPi2 ha raccolto quasi $ 250.000.

Clicca sul link:

Metodo1 Utilizzo degli accessori

Passaggio 1: materiali

● 1 x Raspberry Pi 4 modello B

● 1 x scheda TF con immagine

● 1 x alimentatore Raspberry Pi

● 1 monitor da 10,1 pollici

● 1 x alimentatore per monitor

● 1 x cavo HDMI

● 1 x tastiera e mouse

● 1 x led RGB (catodo comune)

● 4 x ponticelli (da femmina a femmina)

Passaggio 2: schema di collegamento

Ci sono in realtà tre luci nel LED a colori RGB, che sono luce rossa, luce verde e luce blu. Controlla queste tre luci per emettere luce di intensità diverse e, se miscelate, possono emettere luce di vari colori. I quattro pin sulla luce LED sono GND, R, G e B, rispettivamente. Il LED RGB che ho usato è un catodo comune e la connessione al Raspberry Pi è la seguente:

LED RGB RaspberryPi 4B (nel nome della funzione)

GPIO0 1 ROSSO

GPIO1 3 VERDE

GPIO2 4 BLU

GND 2 GND

La seconda immagine è la connessione hardware

Passaggio 3: configurare per SPI

Poiché dobbiamo utilizzare l'SPI per controllare l'RGB, dobbiamo prima abilitare l'interfaccia SPI, che è disabilitata per impostazione predefinita. È possibile seguire i passaggi seguenti per abilitare l'interfaccia SPI:

Innanzitutto, puoi utilizzare la GUI del desktop andando su Pi start MenupreferencesRaspberry Pi Configuration, come mostrato nella prima immagine.

In secondo luogo, vai su "Interfacce" e abilita SPI e fai clic su OK (la seconda immagine).

Infine, riavvia il tuo Pi per assicurarti che le modifiche abbiano effetto. Fare clic su Pi Menu StartPreferenzeSpegnimento. Dal momento che abbiamo solo bisogno di riavviare, fai clic sul pulsante Riavvia.

Passaggio 4: il codice

Inizieremo scrivendo il nostro codice Python, in primo luogo, inizieremo importando alcune librerie di cui avremo bisogno per integrare il nostro codice con il mondo Minecraft. Quindi, importeremo la libreria del tempo, in particolare una funzione chiamata sleep. La funzione sleep ci consentirà di attendere un intervallo specifico prima di eseguire una funzione. Ultimo ma non meno importante, importiamo la libreria RPi. GPIO che ci permette di controllare il GPIO su Raspberry Pi.

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

E questo è tutto, abbiamo finito con l'importazione delle librerie, ora è il momento di usarle! Per prima cosa, è usare la libreria Minecraft, vogliamo connettere il nostro script python al mondo Minecraft, possiamo farlo invocando la funzione init() della libreria MCPI e quindi impostare la modalità GPIO e disabilitare l'avviso.

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

Ora, definiamo alcuni colori dell'arcobaleno in esadecimale in modo da poter cambiare i colori RGB.

BIANCO = 0xFFFFFF ROSSO = 0xFF0000 ARANCIONE = 0xFF7F00 GIALLO = 0xFFFF00 VERDE = 0x00FF00 CIANO = 0x00FFFF BLU = 0x0000FF VIOLA = 0xFF00FF MAGENTA = 0xFF0090

Successivamente, dobbiamo definire alcune variabili per registrare il colore del blocco di lana, che è già definito nell'elenco dei blocchi di Minecraft.

L_BIANCO = 0 L_ROSSO = 14 L_ARANCIO = 1 L_GIALLO = 4 L_VERDE = 5 L_CIANO = 9 L_BLU = 11 L_VIOLA = 10 L_MAGENTA = 2

L'ID del blocco di lana in Minecraft è 35. Ora, dobbiamo configurare il pin per i led RGB e configurarli.

pin_rosso = 17 pin_verde = 18 pin_blu = 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)

Quindi, imposta il PWM per ciascun pin, nota che l'intervallo del valore PWM è 0-100. Qui, impostiamo prima il colore del led RGB su bianco (100, 100, 100).

rosso = GPIO. PWM(red_pin, 100)

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

Di seguito è necessario creare due funzioni, che possono essere utilizzate per decodificare il colore e accendere il led RGB! Nota che la funzione map2hundred() serve a mappare i valori da 255 a 100, come abbiamo detto prima, il valore PWM dovrebbe essere 0-100.

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

def set_color(codice_colore): # Decodifica valore_rosso = codice_colore >> 16 & 0xFF valore_verde = codice_colore >> 8 & 0xFF valore_blu = codice_colore >> 0 & 0xFF

# Valori della mappa valore_rosso = map2hundred(valore_rosso) valore_verde = map2hundred(valore_verde) valore_blu = map2hundred(valore_blu)

# Accendere! rosso. ChangeDutyCycle(valore_rosso) verde. ChangeDutyCycle(valore_verde) blu. ChangeDutyCycle(valore_blu)

Molto bene! È ora di avviare il nostro programma principale, aspetta, un'altra variabile dovrebbe essere definita per registrare il codice colore del blocco di lana prima del programma principale:

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) mentre True: x, y, z = mc.player.getPos() # posizione giocatore (x, y, z) block = mc.getBlockWithData(x, y-1, z) # ID blocco #print(block) if 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 blocco.dati == W_ GIALLO: print("Giallo!") set_color(GIALLO) 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) tranne KeyboardInterrupt: pass GPIO.cleanup()

Poiché il programma principale è mostrato sopra, prima di utilizzare alcuni comandi per generare alcuni blocchi di lana colorati, quindi abbiamo bisogno di scoprire la posizione del giocatore in modo da poter ottenere l'ID dei blocchi e il suo codice colore. Dopo aver ottenuto le informazioni sul blocco, utilizzeremo l'istruzione per determinare se il blocco sotto il giocatore è un blocco di lana e se ha il codice colore. Se sì, giudica di che colore è il blocco di lana e chiama la funzione set_color() per cambiare il colore del led RGB come il blocco di lana.

Inoltre, aggiungiamo un'istruzione try/eccetto per catturare l'eccezione dell'interrupt dell'utente quando vogliamo uscire dal programma per cancellare l'output dei pin GPIO.

In allegato il codice completo.

Ben fatto, tanti accessori e troppo complicato vero? Non preoccuparti, vediamo il secondo metodo per realizzare il progetto, che ti farà sentire più flessibile e conveniente, ovvero utilizzare il nostro CrowPi2!

Passaggio 5: il risultato

Apri il gioco ed esegui lo script, vedrai il risultato nel video qui sopra

Quindi useremo CrowPi2 per costruire il prossimo ponte interattivo Rainbow

Passaggio 6: utilizzo dei materiali CrowPi2

●1 x CrowPi2

Passaggio 7: utilizzo del diagramma di connessione CrowPi2

Non c'è bisogno. Ci sono molti sensori e componenti utili (più di 20) su CrowPi2, è tutto in un laptop raspberry pi e una piattaforma didattica STEM che ci consente di realizzare più progetti con facilità e senza fatica! In questo caso, utilizzeremo un modulo attraente e colorato su CrowPi2, che è un modulo a matrice RGB 8x8, che ci consente di controllare 64 led RGB contemporaneamente!

Passaggio 8: utilizzo di CrowPi2: configurazione per SPI

Non c'è bisogno. CrowPi2 è dotato di un'immagine integrata con un sistema di apprendimento! Tutto è stato preparato, il che significa che puoi programmare e imparare direttamente. Inoltre, con il nostro CrowPi2 è facile e già integrato nella scheda come una piattaforma STEAM pronta all'uso.

Passaggio 9: utilizzo di CrowPi2: il codice

Ora è il momento di iniziare il nostro programma! Innanzitutto, importa alcune librerie, come la libreria MCPI che è la libreria Minecraft Pi Python che ci consente di utilizzare un'API molto semplice per integrarci con il mondo Minecraft; libreria temporale che ci consente alla funzione sleep di attendere un intervallo specifico prima di eseguire una funzione; Libreria RPi. GPIO che ci permette di controllare i pin GPIO del Raspberry Pi.

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

Infine, importeremo una libreria chiamata rpi_ws281x che è la libreria RGB Matrix, all'interno della libreria ci sono più funzioni che utilizzeremo come PixelStrip per impostare l'oggetto striscia LED e Color per configurare un oggetto colore RGB su cui illuminare i nostri LED RGB

da rpi_ws281x import PixelStrip, Color

E questo è tutto, abbiamo finito con l'importazione delle librerie, ora è il momento di usarle! Allo stesso modo, la prima cosa è usare la libreria Minecraft, vogliamo connettere il nostro script python al mondo Minecraft, possiamo farlo invocando la funzione init della libreria MCPI:

mc = Minecraft.create()

Ora ogni volta che vogliamo eseguire operazioni sul mondo di minecrat, possiamo usare l'oggetto mc.

Il prossimo passo sarà definire la classe matrice LED RGB che utilizzeremo per controllare i nostri LED RGB, inizializziamo la classe con la configurazione base come numero di led, pin, luminosità ecc…

creiamo una funzione chiamata clean che "pulirà" il meno con un colore specifico dato e anche una funzione chiamata run che inizializzerà l'oggetto LED RGB effettivo la prima volta che vogliamo usarlo.

classe RGB_Matrix:

def _init_(self):

# Configurazione della striscia LED:

self. LED_COUNT = 64 # Numero di pixel LED.

self. LED_PIN = 12 # pin GPIO connesso ai pixel (18 usa PWM!).

self. LED_FREQ_HZ = 800000 # Frequenza del segnale LED in hertz (solitamente 800khz)

self. LED_DMA = 10 # Canale DMA da utilizzare per la generazione del segnale (prova 10)

self. LED_BRIGHTNESS = 10 # Imposta a 0 per il più scuro e 255 per il più luminoso

self. LED_INVERT = False # True per invertire il segnale

self. LED_CHANNEL = 0 # impostato su '1' per GPIO 13, 19, 41, 45 o 53

# Definire le funzioni che animano i LED in vari modi. def clean(self, strip, color):

# cancella tutti i LED contemporaneamente

for i in range(strip.numPixels()):

strip.setPixelColor(i, colore)

strip.show()

def run(self):

# Crea un oggetto NeoPixel con la configurazione appropriata.

striscia = PixelStrip(self. LED_COUNT, self. LED_PIN, self. LED_FREQ_HZ, self. LED_DMA, self. LED_INVERT, self. LED_LUMINOSITÀ, self. LED_CHANNEL)

Tentativo:

striscia di ritorno

tranne KeyboardInterrupt:

# pulire il LED della matrice prima dell'interruzione

self.clean (striscia)

Dopo aver finito con quanto sopra, è il momento di invocare quelle classi e creare oggetti che possiamo usare nel nostro codice, prima creiamo un oggetto matrice LED RGB che possiamo usare usando la classe che abbiamo creato in precedenza:

matriceObject = RGB_Matrix()

Ora usiamo questo oggetto per creare un oggetto striscia LED attiva che useremo per controllare i nostri singoli LED sulla matrice RGB:

striscia = matriceOggetto.run()

Infine, per attivare questa striscia, dovremo eseguire un'ultima funzione:

striscia.inizio()

L'API di Minecraft include molti blocchi, ogni blocco di Minecraft ha il proprio ID. Nel nostro esempio abbiamo preso una certa quantità di blocchi Minecraft e provato a indovinare quale colore è più adatto a loro.

RGB sta per rosso, verde e blu quindi avremo bisogno di 3 valori diversi che vanno da 0 a 255 per ciascuno, i colori possono essere in formato HEX o RGB, stiamo usando il formato RGB per il nostro esempio.

Nel mondo di Minecraft Pi ci sono ID di blocchi normali e ID di blocchi di lana speciali, la lana speciale ha il numero ID 35 ma con numeri secondari che vanno a molti ID diversi … Risolveremo questo problema creando 2 elenchi separati, uno per i blocchi normali e un elenco per blocchi di lana speciali:

Il primo elenco è per i blocchi normali, ad esempio 0 rappresenta il blocco Air, lo imposteremo come colore 0, 0, 0 che è vuoto o completamente bianco, quando il giocatore salterà o volerà nel gioco l'RGB si spegnerà, 1 è un blocco diverso con il colore RGB 128, 128, 128 e così via …

#Colori Arcobaleno

colori_arcobaleno = {

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

}

Per i blocchi di lana facciamo lo stesso ma è importante ricordare che tutti i blocchi hanno un ID di 35, in questo elenco definiamo i sottotipi del blocco che è blocco di lana. Diversi sottotipi di lana hanno colori diversi, ma tutti sono blocchi di lana.

colori_lana = {

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

}

Ora che abbiamo finito di definire il nostro programma principale, le classi e le funzioni, è il momento di integrarci con il nostro sensore a bordo LED RGB CrowPi2.

Il programma principale prenderà i parametri che abbiamo definito in precedenza e metterà l'impatto sull'hardware.

Utilizzeremo il LED RGB CrowPi2 per accenderli in base ai passaggi che eseguiamo all'interno di Minecraft Pi su ciascun blocco, iniziamo!

La prima cosa che faremo è generare alcuni blocchi di lana con i comandi e creare un ciclo while, per mantenere il programma in esecuzione finché giochiamo.

Avremo bisogno di ottenere alcuni dati dal giocatore, per prima cosa usiamo il comando player.getPos() per ottenere la posizione del giocatore, quindi usiamo getBlockWithData() per ottenere il blocco su cui ci troviamo attualmente (la coordinata y è -1 che significa sotto il giocatore)

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)

mentre vero:

x, y, z = mc.player.getPos() # posizione del giocatore (x, y, z)

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

print(blockType)

Quindi controlleremo se il blocco è un blocco di lana, blocco ID numero 35, se lo è faremo riferimento a wool_colors con il colore del blocco basato sull'ID del dizionario e illumineremo il colore giusto di conseguenza.

se blockType == 35:

# colori di lana personalizzati

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

Se non è un blocco di lana, controlleremo se il blocco è attualmente all'interno del dizionario rainbow_colors per evitare eccezioni, se lo è continueremo prendendo il colore e modificando l'RGB.

if str(blockType) in rainbow_colors:

print(arcobaleno_colori[str(blockType)])

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

dormire(0,5)

Puoi sempre provare ad aggiungere più blocchi a rainbow_color per aggiungere più colori e più blocchi di supporto!

Perfetto! Fare progetti utilizzando gli accessori è complicato ma utilizzando il circuito integrato CrowPi2 le cose diventano molto più semplici! Inoltre, ci sono più di 20 sensori e componenti su CrowPi2, che ti consente di realizzare i tuoi progetti ideali e persino progetti di intelligenza artificiale!

Di seguito il codice completo:

Passaggio 10: utilizzo di CrowPi2-il risultato

Apri il gioco ed esegui lo script, vedrai il risultato nel video qui sopra:

Passaggio 11: utilizzo di CrowPi2 - Andare oltre

Ora abbiamo finito il nostro colorato progetto nel gioco Minecraft con CrowPi2. Perché non provare a utilizzare altri sensori e componenti su CrowPi2 per giocare con il gioco, come il joystick per controllare il movimento del giocatore, RFID per generare blocchi basati su diverse schede NFC e così via. Divertiti con il tuo gioco su CrowPi2 e spero che tu possa farlo progetti più incredibili con CrowPi2!

Ora, CrowPi2 è ora su Kickstarter, puoi anche goderti il prezzo interessante.

Allega il link alla pagina Kickstarter CrowPi2