Byg Rainbow Interactive Bridge ved hjælp af Minecraft Raspberry Pi Edition: 11 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:25

I går så jeg min 8-årige nevø spille Minecraft med Raspberry Pi, jeg gav ham før, så fik jeg en idé, der bruger kode til at lave et tilpasset og spændende Minecraft-pi LED-blokke-projekt. Minecraft Pi er en fantastisk måde at komme i gang med Raspberry Pi -mikrocomputeren på, Minecraft Pi er en speciel specialfremstillet version af Minecraft, der giver os mulighed for at interagere med spillet ved hjælp af en dødelig simpel Python API til at tilpasse spiloplevelsen og rekvisitter!

Der er mange projekter, du kan lave i Minecraft -verdenen med Raspberry Pi, men specifikt for os var det ikke nok, vi ledte efter noget udfordrende og blinkende på samme tid. I dette projekt vil vi træde på flere Minecraft -blokke, opdage blokens ID og opdage farven på den specifikke blok, vi trådte på, baseret på den farve, vi tænder vores RGB LED for at skabe interaktivt trinspil!

Jeg vil bruge to metoder til at opnå effekten, den første er at bruge tilbehøret, hvilket kan være meget kaotisk …; den anden bruger CrowPi2 (læringscomputer med mange sensorer, i øjeblikket crowdfundet på Kickstarter: CrowPi2)

lad os komme i gang og se, hvordan du arkiverer et så fantastisk projekt!

Forbrugsvarer

CrowPi2 er nu live på kickstarter nu, CrowPi2 -projektet har indsamlet næsten $ 250k.

Find linket:

Metode 1 Brug af tilbehør

Trin 1: Materialer

● 1 x Raspberry Pi 4 model B

● 1 x TF -kort med billede

● 1 x Raspberry Pi strømforsyning

● 1 x 10,1 tommer skærm

● 1 x Strømforsyning til skærm

● 1 x HDMI -kabel

● 1 x tastatur og mus

● 1 x RGB -led (fælles katode)

● 4 x Jumpere (Kvinde til hun)

Trin 2: Tilslutningsdiagram

Der er faktisk tre lys i RGB -farve -LED'en, som er rødt lys, grønt lys og blåt lys. Styr disse tre lamper for at udsende lys med forskellige intensiteter, og når de blandes, kan de udsende lys i forskellige farver. De fire ben på LED -lyset er henholdsvis GND, R, G og B. Den RGB LED, jeg brugte, er en fælles katode, og forbindelsen til Raspberry Pi er som følger:

RaspberryPi 4B (i funktionsnavn) RGB LED

GPIO0 1 RØD

GPIO1 3 GRØN

GPIO2 4 BLÅ

GND 2 GND

Det andet billede er hardware -forbindelsen

Trin 3: Konfigurer til SPI

Fordi vi skal bruge SPI'en til at styre RGB, skal vi først aktivere SPI -grænsefladen, som er deaktiveret som standard. Du kan følge nedenstående trin for at aktivere SPI -interface:

Først kan du bruge Desktop GUI ved at gå til Pi start MenupreferencesRaspberry Pi Configuration, som det er vist på det første billede.

For det andet skal du navigere til "Interfaces", aktivere SPI og klikke på OK (det andet billede).

Til sidst skal du genstarte din Pi for at sikre, at ændringerne træder i kraft. Klik på Pi Start MenuPreferencesShutdown. Da vi bare skal genstarte, skal du klikke på knappen Genstart.

Trin 4: Koden

Vi starter med at skrive vores python -kode, først starter vi med at importere et par biblioteker, som vi skal bruge for at integrere vores kode med Minecraft -verdenen. Derefter importerer vi tidsbiblioteket, specifikt en funktion kaldet søvn. Søvnfunktionen giver os mulighed for at vente et bestemt interval, før vi udfører en funktion. Sidst men ikke mindst importerer vi RPi. GPIO bibliotek, som giver os mulighed for at styre GPIO på Raspberry Pi.

fra mcpi.minecraft import Minecraft fra tid importere søvnimport RPi. GPIO som GPIO

Og det er det, vi har gjort med at importere bibliotekerne, nu er det tid til at bruge dem! Først og fremmest er at bruge Minecraft -biblioteket, vi vil forbinde vores python -script til Minecraft -verdenen, vi kan gøre dette ved at påberope init () -funktionen i MCPI -biblioteket og derefter indstille GPIO -tilstand og deaktivere advarslen.

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

Nu definerer vi nogle regnbuefarver i hexadecimal, så vi kan ændre RGB -farver.

HVID = 0xFFFFFF RØD = 0xFF0000 ORANGE = 0xFF7F00 GUL = 0xFFFF00 GRØN = 0x00FF00 CYAN = 0x00FFFF BLÅ = 0x0000FF PURPLE = 0xFF00FF MAGENTA = 0xFF0090

Dernæst skal vi definere nogle variabler for at registrere farven på uldblokken, som allerede er defineret i Minecraft -bloklisten.

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

Vi ID på uldblokken i Minecraft er 35. Nu skal vi konfigurere stiften til RGB -led og konfigurere dem.

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)

Konfigurer derefter PWM for hver pin. Bemærk, at intervallet for PWM-værdi er 0-100. Her satte vi farven på RGB led til hvid (100, 100, 100) først.

rød = GPIO. PWM (rød_nål, 100)

grøn = GPIO. PWM (grøn_nål, 100) blå = GPIO. PWM (blå_nål, 100) rød.start (100) grøn.start (100) blå.start (100)

Følgende er at oprette to funktioner, som kan bruges til at afkode farve og tænde RGB førte op! Bemærk, at map2hundred () -funktionen er at kortlægge værdier fra 255 til 100, som vi sagde før nævnt, bør PWM-værdien være 0-100.

def map2hundred (værdi): return int (værdi * 100/255)

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

# Kortværdier rød_værdi = map2hundred (red_value) green_value = map2hundred (grøn_værdi) blå_værdi = map2hundred (blå_værdi)

# Oplyse! red. ChangeDutyCycle (rød_værdi) grøn. ChangeDutyCycle (grøn_værdi) blå. ChangeDutyCycle (blå_værdi)

Godt klaret! Det er tid til at starte vores hovedprogram, vent, en anden variabel bør defineres for at registrere farvekoden på uldblok før hovedprogrammet:

last_data = 0 prøve: 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) mens True: x, y, z = mc.player.getPos () # spillerposition (x, y, z) blok = mc.getBlockWithData (x, y-1, z) # blok ID #print (blok) hvis block.id == ULD og sidste_data! = Blok.data: hvis blok.data == W_RØD: print ("Rød!") Sæt_farve (RØD) hvis blok.data == W_ORANGE: udskriv ("Orange!") Sæt_farve (ORANGE) hvis block.data == W_ GUL: print ("Gul!") Set_color (GUL) hvis block.data == W_GREEN: print ("Green!") Set_color (GREEN) if block.data == W_CYAN: print ("Cyan!") Set_color (CYAN)) hvis 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) undtagen KeyboardInterrupt: pass GPIO.cleanup ()

Som hovedprogrammet er vist ovenfor, først for at bruge nogle kommandoer til at generere nogle farverige uldblokke, så skal vi finde ud af spillerens position, så vi kan få blokkenes id og dets farvekode. Efter at have modtaget blokoplysningerne, vil vi bruge erklæringen til at afgøre, om blokken under afspilleren er en uldblok, og om den har farvekoden. Hvis ja, bedøm hvilken farve uldblokken er, og ring til funktionen set_color () for at ændre farven på RGB -led den samme som uldblokken.

Derudover tilføjer vi en prøv/undtag -sætning for at fange undtagelsen for brugerafbrydelse, når vi vil afslutte programmet for at rydde output fra GPIO -ben.

Vedhæftet er den komplette kode.

Godt gået, så meget tilbehør og for kompliceret, ikke? Bare rolig, lad os se den anden metode til at opnå projektet, som får dig til at føle dig mere fleksibel og bekvem, som bruger vores CrowPi2!

Trin 5: Resultatet

Åbn spillet og kør scriptet, du vil se resultatet i videoen ovenfor

Derefter vil vi bruge CrowPi2 til at bygge Rainbow interaktiv bro næste

Trin 6: Brug af CrowPi2-materialer

● 1 x CrowPi2

Trin 7: Brug af CrowPi2- forbindelsesdiagram

Intet behov. Der er mange nyttige sensorer og komponenter (mere end 20) på CrowPi2, det er alt i en hindbær pi -bærbar computer og STEM -uddannelsesplatform, der giver os mulighed for let at udføre flere projekter og uden sved! I dette tilfælde vil vi bruge et attraktivt og farverigt modul på CrowPi2, som er et 8x8 RGB -matrixmodul, som giver os mulighed for at styre 64 RGB -led på samme tid!

Trin 8: Brug af CrowPi2- Konfigurer til SPI

Intet behov. CrowPi2 leveres med et indbygget billede med et læringssystem! Alt er forberedt, hvilket betyder, at du kan programmere og lære direkte. Desuden er det med vores CrowPi2 let og allerede integreret i tavlen som en STEAM -platform klar til brug.

Trin 9: Brug af CrowPi2- koden

Nu er det tid til at starte vores program! Først skal du importere et par biblioteker, f.eks. MCPI -bibliotek, som er Minecraft Pi Python -biblioteket, der giver os mulighed for at bruge en meget enkel API til at integrere med Minecraft -verden; tidsbibliotek, som giver os mulighed for at sove funktion til at vente et bestemt interval, før vi udfører en funktion; RPi. GPIO bibliotek, som giver os mulighed for at styre Raspberry Pi GPIO benene.

fra mcpi.minecraft import Minecraft fra tid import søvnimport RPi. GPIO som GPIO

Endelig importerer vi et bibliotek kaldet rpi_ws281x, som er RGB Matrix -biblioteket, inde i biblioteket er der flere funktioner, som vi vil bruge, såsom PixelStrip til at konfigurere LED -stripobjektet og Color til at konfigurere et RGB -farveobjekt til at lyse vores RGB -lysdioder

fra rpi_ws281x import PixelStrip, farve

Og det er det, vi har gjort med at importere bibliotekerne, nu er det tid til at bruge dem! Som det samme er den første ting at bruge Minecraft -biblioteket, vi vil forbinde vores python -script til Minecraft -verdenen, vi kan gøre dette ved at påberåbe init -funktionen i MCPI -biblioteket:

mc = Minecraft.create ()

Nu hver gang vi vil udføre operationer i minekratverdenen, kan vi bruge mc -objektet.

Næste trin vil være at definere RGB LED -matrixklassen, som vi vil bruge til at styre vores RGB -lysdioder, vi initialiserer klassen med grundlæggende konfiguration såsom antal lysdioder, stifter, lysstyrke osv …

vi opretter en funktion kaldet ren, som vil "rense" det mindre med specifik farve givet og også en funktion kaldet run, der vil initialisere det faktiske RGB LED -objekt ved første gang, vi vil bruge det.

klasse RGB_Matrix:

def _init _ (selv):

# LED -båndkonfiguration:

self. LED_COUNT = 64 # Antal LED -pixels.

self. LED_PIN = 12 # GPIO -pin forbundet til pixels (18 bruger PWM!).

self. LED_FREQ_HZ = 800000 # LED -signalfrekvens i hertz (normalt 800khz)

self. LED_DMA = 10 # DMA -kanal, der skal bruges til at generere signal (prøv 10)

self. LED_BRIGHTNESS = 10 # Indstillet til 0 for mørkeste og 255 for lyseste

self. LED_INVERT = Falsk # Sandt for at invertere signalet

self. LED_CHANNEL = 0 # indstillet til '1' for GPIO'er 13, 19, 41, 45 eller 53

# Definer funktioner, der animerer lysdioder på forskellige måder. def clean (selv, strip, farve):

# tør alle LED'er på én gang

for i inden for rækkevidde (strip.numPixels ()):

strip.setPixelColor (i, farve)

strip.show ()

def løb (selv):

# Opret NeoPixel -objekt med passende konfiguration.

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

prøve:

returstrimmel

undtagen KeyboardInterrupt:

# rengør matrix -LED før afbrydelse

self.clean (strip)

Når vi har gjort med ovenstående, er det tid til at påberåbe disse klasser og oprette objekter, som vi kan bruge i vores kode, først lad os oprette et RGB LED -matrixobjekt, som vi kan bruge ved hjælp af den klasse, vi har oprettet tidligere:

matrixObject = RGB_Matrix ()

Lad os nu bruge dette objekt til at oprette aktive LED -strimmelobjekter, som vi vil bruge til at styre vores individuelle lysdioder på RGB Matrix:

strip = matrixObject.run ()

Endelig for at aktivere denne strimmel, skal vi køre en sidste funktion:

strip.begin ()

Minecraft API indeholder mange blokke, hver Minecraft -blok har sit eget id. I vores eksempel har vi taget en vis mængde Minecraft -blokke og forsøgt at gætte hvilken farve der er bedst egnet til dem.

RGB står for rødt, grønt og blåt, så vi skal bruge 3 forskellige værdier fra 0 til 255 for hver enkelt, farver kan være HEX- eller RGB -format, vi bruger RGB -formatet til vores eksempel.

I Minecraft Pi -verdenen er der normale blokke -id'er og specielle uldblokke -id'er, den særlige uld kommer under ID -nummer 35, men med subnumre, der spænder fra mange forskellige id'er … Vi løser dette problem ved at oprette 2 separate lister, en til normale blokke og en liste til særlige uldblokke:

Den første liste er for normale blokke, f.eks. 0 repræsenterer luftblok, vi sætter den farve 0, 0, 0 som er blank eller fuldstændig hvid, når spilleren hopper eller flyver i spillet, slukker RGB, 1 er en anden blok med RGB -farve 128, 128, 128 og så videre …

#Rainbow farver

regnbue_farver = {

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

}

For uldblokke gør vi det samme, men det er vigtigt at huske, at alle blokke har et ID på 35, i denne liste definerer vi undertyperne af blokken, som er uldblok. Forskellige uldundertyper har forskellige farver, men alle er uldblokke.

uldfarver = {

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

}

Når vi er færdige med at definere vores hovedprogram, klasser og funktioner, er det tid til at integrere med vores CrowPi2 RGB LED ombord sensor.

Hovedprogrammet tager de parametre, vi definerede tidligere, og påvirker hardwaren.

Vi kommer til at bruge CrowPi2 RGB LED for at tænde dem baseret på de trin, vi gør inde i Minecraft Pi på hver blok, lad os komme i gang!

Den første ting, vi vil gøre, er at generere nogle uldblokke med kommandoer og oprette et stykke loop, for at holde programmet kørende, så længe vi spiller spillet.

Vi skal hente nogle data fra afspilleren, først bruger vi kommandoen player.getPos () for at få spillerens position, derefter bruger vi getBlockWithData () til at få den blok, vi i øjeblikket står på (y -koordinaten er -1, som er betyder under afspilleren)

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)

mens det er sandt:

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

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

print (blokType)

Derefter kontrollerer vi, om blokken er uldblok, blok -ID -nummer 35, hvis det er det, vil vi henvise til wool_colors med blokens farve baseret på ordbogens ID og tænde den rigtige farve i overensstemmelse hermed.

hvis blockType == 35:

# brugerdefinerede uldfarver

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

Hvis det ikke er uldblok, kontrollerer vi, om blokken i øjeblikket er inde i regnbue_farver -ordbogen for at undgå undtagelser, hvis det er det, fortsætter vi med at tage farven og ændre RGB.

hvis str (blockType) i rainbow_colors:

print (regnbue_farver [str (blockType)])

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

søvn (0,5)

Du kan altid prøve at tilføje flere blokke til rainbow_color for at tilføje flere farver og understøtte flere blokke!

Perfekt! At udføre projekter med tilbehør er kompliceret, men ved hjælp af det integrerede CrowPi2 -kredsløb bliver tingene meget lettere! Desuden er der mere end 20 sensorer og komponenter på CrowPi2, som giver dig mulighed for at opnå dine ideelle projekter og endda AI -projekter!

Nedenfor er den komplette kode:

Trin 10: Brug af CrowPi2-the Result

Åbn spillet og kør scriptet, du vil se resultatet i videoen ovenfor:

Trin 11: Brug af CrowPi2- Gå videre

Nu er vi færdige med vores farverige projekt i Minecraft -spillet med CrowPi2. Hvorfor ikke prøve at bruge andre sensorer og komponenter på CrowPi2 til at lege med spillet, såsom joystick til at styre spillerens bevægelse, RFID til at generere blokke baseret på forskellige NFC -kort osv. God fornøjelse med dit spil på CrowPi2 og håber du kan gøre det mere utrolige projekter med CrowPi2!

Nu er CrowPi2 på Kickstarter nu, du kan også nyde den attraktive pris.

Vedhæft Kickstarter -sidelinket CrowPi2