Spel på Raspberry Pi Pico

I det här inlägget vill jag prata om spel på Raspberry Pi Pico.

Jag minns min första dumbphone, som kallades för "telefon" på den tiden. Den kunde spela enkla spel som Snake. Det var en banbrytande utveckling.

Tidigare var du tvungen att ha med dig en separat handdator som spelade Tetris eller ett mer dynamiskt spelsystem som en Gameboy.

Raspberry Pi Pico är en ganska kraftfull mikrokontroller jämfört med vad handdatorer körde på på 90-talet. Naturligtvis erbjuder den oss möjligheten att spela spel från den tiden.

Hur kraftfull är Raspberry Pi Pico?

Jämfört med en 80-talskonsol är Raspberry Pi Pico extremt kraftfull. 

Om du programmerar ett spel som liknar resurskraven i ett spel från 1980-talet kommer Raspberry Pi Pico förmodligen att klara det utan problem.

Det är på 90-talet som det börjar bli lite svårare att dra en så tydlig slutsats.

Om du å ena sidan ser det som en enhet som kan spela spel som liknar dem du hittar på en Gameboy eller en mobiltelefon, kommer du förmodligen att bli nöjd.

I slutet av 90-talet blev spelen dock mycket mer krävande. Du kommer till exempel inte att spela Quake 3 (ett spel från 1999) på Pico.

Även om Raspberry Pi Pico kan spela Doom (1993) var det ett sex månader långt arbete för den som kodade spelet, eftersom det var ganska svårt att komprimera spelet till de 2 MB lagringsutrymme som Raspberry Pi Pico har.

Även om Pico har två 133 MHz-processorer har den ett begränsat RAM-minne och lagringsutrymme, vilket gör det svårt.

Låt oss se hur den står sig i jämförelse med en Gameboy:

Varför spela spel på Pico och inte på Zero/Pi 4?

Det är en bra fråga.

Som du vet är Raspberry Pi Pico en mikrokontroller medan Raspberry Pi Zero eller Pi 4 är mikrodatorer.

Båda kan spela spel, men Raspberry Pi Pico är mycket mer begränsad.

Om du vill bygga en emulator eller ett spelsystem från Raspberry Pi Zero eller Pi 4s idag (år 2022) är det dock bäst att du redan har en sådan, annars är den största flaskhalsen lagret.

Det är mycket svårt att få tag på en Pi Zero och ganska svårt att få tag på en Pi 4.

Å andra sidan finns det gott om Pico. Den startar också upp nästan omedelbart, medan mikrodatorn Pis måste gå igenom en långvarig uppstartsprocess.

Pico håller också mycket längre. Om du vill ha en mobil installation som kan köras i timmar och är bärbar är Pico mycket bättre.

Slutligen är Pico också rikligt förekommande i lager.

För att vara rättvis mot Pi Zero och Pi 4 kan du definitivt spela bättre spel och få bättre emuleringsresultat med dessa mikrodatorer. Som du kommer att se i nästa avsnitt kämpar Pico med att spela spel som Zero eller Pi 4 klarar utan problem.

Vilka spel kan Raspberry Pi Pico spela?

Vi börjar med att se vad pysselmänniskorna har lyckats spela med Raspberry Pi Pico.

RP2040 Doom är svaret på frågan "Kommer det att bli Doom?".

Ja! Raspberry Pi Pico kan spela Doom.

En kille vid namn Graham Sanderson från Austin, Texas, lyckades anpassa Doom till Raspberry Pi Pico.

Hans magiska formel?

while (!convice_myself_its_probably_impossible()) {
    do_some_more();
}

Han förklarade i sin dokumentation av processen att han möttes av flera begränsningar på grund av de hårdvaruspecifikationer som Raspberry Pi Pico hade. Det är trots allt inte en enhet som är avsedd för spel.

Graham beslutade dock också att göra det ännu svårare att anpassa Doom. Han ville ha den autentiska upplevelsen av Doom, vilket innebar 320×200 (färg) upplösning, stereoljud, OPL2-musik, sparande och laddning, flerspelarlägen i nätverk och andra funktioner som finns i originalet.

Att packa in så mycket spel i Raspberry Pi Pico innebar utmaningar med minnet. Både RAM-minne och lagringsutrymme var viktiga frågor.

För det första har Raspberry Pi Pico bara 2 MB lagringsutrymme, men sharewareversionen av Doom är dubbelt så stor. Även om andra utvecklare kanske väljer att skära bort vissa funktioner som splash screens och downsampling av texturer, ville Graham inte göra det.

RAM-minne var också en annan fråga, eftersom källkoden för Chocolate Doom kräver cirka 1 MB RAM-minne medan Pico bara har cirka 264 KB. Det är ont om minne eftersom rendering av grafiken tar upp en stor del av RAM-utrymmet, men RAM är också mycket viktigt för att spelet ska fungera smidigt. För att hantera båda aspekterna var Graham tvungen att göra vad han kallade "fettsugning".

Du kan läsa mer på följande adress dokumentationen, titta på hans spellista på YouTube eller . granskning av koden.

NES-emulator

Raspberry Pi Pico har framgångsrikt gjorts om till en NES-emulator.

I en tråd i Emulator Zone ForumEnligt användaren ropgar kan Raspberry Pi Pico emulera en NES, den kan göra 60 bilder per sekund och kan emulera APU och PPP perfekt.

Ropgar använder ett PS/2-tangentbord som styrenhet, men du kan också använda den ursprungliga NES-kontrollen.

Ljudet är bra och det finns inga störningar i video och bakgrundsmusik.

Pico har cirka 1,5 MB flashutrymme kvar för olika spel, som kan väljas genom att trycka på Caps Lock för att växla mellan spelen. 

De spel som ropgar lyckades ladda in på sin demo är Pacman, Arkanoids, DK, DK Jr, BubbleBobble, Galaga och många andra.

Den enda nackdelen är att det inte finns någon offentlig källkod eller handledning om hur man gör detta.

Gameboy-emulator för Raspberry Pi Pico

Du kan göra ett eget Gameboy-fodral och sedan använda Raspberry Pi Pico för att emulera Gameboy.

Det svåra är att det faktiskt inte är något som har varit särskilt framgångsrikt. Med andra ord kan det du bygger fungera, men inte alltid.

Låt oss ta en titt på de olika alternativen.

Rust Gameboy-emulator (OxidGB Pico Port)

När jag såg Pokemon-bilden på skärmen blev jag genast glad.

James Selby skrev dock om utmaningarna och bristerna med sin Gameboy-emulator, skriven i Rust, som heter OxidGB Pico Port.

"Det här har varit en resa - en frustrerande resa, men en resa som jag ändå har njutit av ur ett utbildningsperspektiv", sade Selby.

Problem och vinster

Här är den största utmaningen: Rust Gameboy-emulatorn "är tyvärr inte direkt spelbar i sitt nuvarande skick".

Selby säger att spel bara får ungefär 10 FPS eftersom emulatorns kod är en flaskhals, liksom det långsamma SPI-gränssnittet till skärmen.

Det är möjligt att påskynda saker och ting, men det kräver tid att planera och genomföra.

Ingången har inte konfigurerats eftersom spelen inte gick att spela. 

Testning av OxidGB Pico Port

Om du vill prova det kan du följa Selbys instruktioner på hans Github-repo för OxidGB Pico Port.

RP2040_GB-emulator

En annan emulator som du kan prova är RP2040_GB, som bygger på den Jordnöts-GB emulator.

Prestandan på RP2040_GB är hyfsad, och Koshkouei säger att hans installation "körs med mer än 70 fps utan ljudemulering". Med ramöverhoppning och interlacing kan han köra upp till 120 fps."

Som du kan se spelar RP2040_GB Pokemon. Stegen för att få in en ROM på RP2040 är följande:

• Du måste ha Pico SDK
• Konvertera .gb eller . .gbc ROM till en C header-fil med hjälp av xxd program
• Ändra den konverterade filen genom att lägga till två rader kod (i Github readme)
• Kopiera ROM till src mappen och kompilera.

Den här emulatorn har vissa begränsningar:

• "Den här emulatorn är felaktig och är ett pågående arbete ... vissa spel kan köras felaktigt eller inte alls." 
• Gameboy Color-spel ger ett fel
• Inte optimerad för mikrokontroller: Koshkouei föreslog att "Användning av en APU som är optimerad för utrymme och hastighet" kan hjälpa.

Se RP2040_GB:s Github-repo här.

Mega Games Compilation med Raspberry Pi Pico

Det bästa med det här projektet är att det är enkelt och att instruktionerna är tillräckliga för att du snabbt ska kunna börja bygga en Raspberry Pi Pico-spelkonsol.

Roger Bühler har delar, instruktioner och demonstrationer på sin Github.

Mega Games Compilation innehåller följande spel:

1. Tiny Gilbert
2. Små knep
3. Tiny Invaders v3.1
4. Tiny Pinball v2
5. Tiny Pacman v1.2
6. Tiny Bomber v1.3
7. Tiny Bike v1.2
8. Tiny Bert 1.1
9. Tiny Arkanoid v2
10. Små Tris v2.1e
11. Liten plakett
12. Små DDug
13. Tiny Missile v1.1
14. Tiny Lander v1.0 ( av Roger Buehler )
15. Små Morpion
16. Små rör

Du behöver följande delar:

1. Raspberry Pi Pico
2. SSD1309 128x64px SPI OLED-skärm (2,42-tumsskärm i förhållandet 2:1)
3. Piezo-summer
4. Fem knappar
5. Brädbräda
6. Startkablar
7. Valfritt: motstånd på 10 ohm, elektrolytisk kondensator som är dimensionerad för minst 10V och 220uF.

Du behöver också Adafruits SSD1306-bibliotek.

Så här ansluter du skärmen:

• GND -> Display GND 
• 3V3(OUT) -> Display VCC 
• GP16 -> Visa DC (datakommando) 
• GP17 -> Visa CS (kanalval) 
• GP18 -> Display SCL (klocka) 
• GP19 -> Display SDA (MOSI) 
• GP20 -> Display RES (återställning)

Och för att koppla ihop knapparna:

• GP15 -> knappen UP 
• GP14 -> knappen DOWN 
• GP13 -> knappen LEFT 
• GP12 -> knappen RIGHT (höger) 
• GP11 -> knapp FIRE (alla knappar till GND)

Och för att ansluta piezo-summaren:

• GP10 -> Summer (+) 
• GND -> Summer (-)

Installation av programvara:

För att installera programvaran måste du använda Arduino IDE.

Tamagotchi-liknande spel på Raspberry Pi Pico (Pico-Tamachibi)

Varför kallas den Pico-Tamachibi?

Enligt Kevin McAleer, skaparen av denna enhet, betyder "tama" "ägg" och "chibi" hänvisar till grafik där karaktären har ett stort huvud. 

Det är enkelt att skapa Tamachibi eftersom Kevin går igenom varje steg i sin 90 minuter långa handledning.

Bygg din egen spelmaskin

Om du vill göra din egen Raspberry Pi Pico-spelmaskin finns det två allmänna sätt att göra det på: köpa ett färdigt kit eller bygga det själv.

Färdiga kit vs DIY Raspberry Pi Pico spelhårdvara

Det är möjligt att börja från grunden, men du kanske vill hoppa över besväret med att bygga ditt eget system och köpa ett färdigt paket.

Det finns några RP2040-baserade byggsatser som gör att du kan börja spela eller utveckla egna spel direkt.

Låt oss titta på Pimoroni Picosystem och sedan jämföra det med processen att bygga något liknande med hjälp av enskilda delar.

Pimoroni Picosystem

Låt oss ta en titt på Pimoroni Picosystem.

Som du kan se är den mycket större än Raspberry Pi Pico W, men det beror också på att den har ett fyrvägs-D-pad, fyra knappar, en LCD-skärm, ett litiumjonbatteri, en piezohögtalare och en USB-C-port, bland annat.

Den har samma processor och RAM-minne, eftersom både Picosystem och Pico använder RP2040-chipet. Här är de fullständiga specifikationerna:

• Drivs av RP2040 (Dual Arm Cortex M0+ med 264 kB SRAM)
• 16 MB QSPI flash med stöd för XiP
• 1,54″ färg SPI IPS LCD (240×240 och 120×120 lägen)
• D-pad och knappar
• 525mAh LiPo-batteri (6 timmar+)
• Piezo-summer/högtalare
• På/av-knappen
• RGB LED
• Programmerbar och uppladdningsbar via USB-C (kabel ingår inte)

Grafiska lägen

PicoSystem stöder två grafiklägen.

• 240×240: LCD-skärmens ursprungliga upplösning.
• 120×120: pixelfördubblat läge (sparar RAM)

Hur ser spel på Picosystem ut?

Det är enkelt att spela på Picosystem. Tryck bara på strömbrytaren så får du det förinstallerade spelet Super Square Bros.

Spelet är ett enkelt plattformsspel, ungefär som Mario.

Pimoroni har även inkluderat andra spel:

• Super Square Bros. by Scorpion Games - Ett hoppigt fyrsidigt plattformsspel (förinstallerat spel)
• Prickar - Ett pussel som knäcker prickar. Skapa kedjor av två eller fler och tävla för att få flest poäng.
• Stenar och diamanter - Klassiskt spel där du måste undvika stenar och ta diamanter.
• Geometri - Slå sönder rymdblocken med lasrar för att göra mindre rymdblock!
• Rainbow Ascent - Dark Souls med procedurellt genererade vertikala hoppande pussel. Lycka till.
• Super Blit Kart by Daft_Freak - Ett "Mode7"-baserat racingspel.

För att installera dessa spel gör du följande:

• Ladda ner filen.
• Anslut Picosystem till datorn
• Håll ned X-knappen och tryck på strömknappen.
• Picosystemet ska monteras som en enhet som heter RPI-RP2.
• Kopiera den nedladdade .uf2-filen till enheten. Den laddas automatiskt.

Av någon anledning fungerade inte min USB-C-till-USB-C-kabel, men USB-A-till-USB-C-kabeln fungerade med Picosystem. Om du inte ser den röda lysdioden lysa, prova en annan kabel.

Programmera dina egna spel

Det bästa med Picosystem är att det tillhandahåller ett system för att du ska kunna skapa dina egna spel.

PicoSystem har ett särskilt API som kan hjälpa dig att skapa dina spel istället för att programmera från grunden.

Det tar också bort mycket av det tråkiga arbete som krävs för att köpa enskilda delar som LCD-skärm, knappar, bryggkablar, brödbräda och sedan ta reda på vilka bibliotek och paket som krävs för att få allt detta att fungera.

PicoSystemets API har funktioner för att rita saker på skärmen, för att ge ut ljud, hårdvarufunktioner och andra funktioner. Detta gör det lättare för dig att bygga ditt spel.

Precis som Raspberry Pi Pico kan PicoSystem kodas i C++ eller MicroPython. 

Är det lätt att programmera ett spel med Picosystem?

Jag rekommenderar att du har lite tid och tålamod för att bygga ditt eget spel med Picosystem.

Dokumentationen innehåller grunderna för att du ska komma igång, men det är bäst om du har några förkunskaper om spelprogrammering.

Den största utmaningen för nybörjare är att det inte finns många resurser där ute som lär dig att koda exempelprojekt. Här är dock en lista med referenser som kan hjälpa dig:

Picosystem MicroPython-guide (i readme)

Picosystem MicroPython-exempel

Picosystem C++ Github

Picosystem C++-exempel

Picosystem API fusklapp, plus bild, teckensnittskonverterare (på sidofältet)

Gör-det-själv-system: Skapa hårdvaran

YouMakeTechs guide visar hur man tillverkar en komplett spelkonsol med hölje, ljudsystem och permanent lödning.

För vår jämförelse ska vi se hur mycket det skulle kosta att bygga en självbyggarenhet jämfört med Picosystem, som är ett komplett kit.

Låt oss se de slutliga kostnaderna för olika nivåer av DIY-installationer:

Bara en varning - YouMakeTech säger att du kan bygga den här för mindre än $20. Enligt min undersökning skiljer sig dock kostnaderna för en DIY-uppsättning som motsvarar Picosystem inte så mycket, särskilt om man beaktar programvaran och bekvämligheten.

Men det är också ett bra sätt att lära sig att göra det själv. En sak som utmanade mig var skärmen. Medan YouMakeTechs exempel använder en I2C-anslutning, använde skärmen som jag hade ett 4-stifts SPI-gränssnitt. Det kräver antingen en ändring i kodningen eller en modifiering av hårdvaran för att kunna fortsätta. Om du gillar utmaningar är DIY-vägen något för dig.

Vilka är fördelarna med att göra det själv jämfört med Picosystem?

Skapa ett Pong-liknande spel på Picosystem vs DIY-systemet

Ett av mina nyfikna experiment handlar om att förstå hur mycket arbete det tar att utveckla ett spel med Picosystem jämfört med att göra det från grunden.

För att jämföra de två systemen kommer jag att bygga ett Pong-liknande spel för en spelare på både YouMakeTechs DIY-system och Picosystem.

Spelets utgångspunkt är enkel. Det är ett Pong-liknande spel för en spelare som ger dig 10 poäng varje gång din boll studsar mot paddeln. Om den faller till botten av skärmen får du ett "Game Over"-meddelande.

Att skapa spelet på båda systemen följer ett enkelt arbetsflöde som alla leder till Thonny.

Du måste flasha MicroPython på Pico och sedan använda Thonny för att koda ditt program. 

Den MicroPython-fil som du flashar på Picosystem skiljer sig från den officiella MicroPython UF2-filen, så se till att du flashar rätt eftersom Picosystem kommer att köras med den officiella MicroPython-versionen. Den kommer bara inte att fungera som avsett.

Låt oss se på några grundläggande skillnader mellan de två. Jag utesluter spellogik här och jämför endast skillnader i interaktion och programmeringsmönster mellan hårdvara och mjukvara.

Du kan se YouMakeTechs kod här.

Första skillnaden: hårdvarukod

Det är mycket "rått" när du väljer att göra det själv. Här är lite kod för att initialisera displayen, GPIO och knapparna som du inte behöver göra med Picosystem:

from machine import Pin, PWM, I2C,
from ssd1306 import SSD1306_I2C
…
# Buttons
up = Pin(2, Pin.IN, Pin.PULL_UP)
down = Pin(3, Pin.IN, Pin.PULL_UP)
left = Pin(4, Pin.IN, Pin.PULL_UP)
right = Pin(5, Pin.IN, Pin.PULL_UP)
button1 = Pin(6, Pin.IN, Pin.PULL_UP)
button2 = Pin(7, Pin.IN, Pin.PULL_UP)

# Buzzer connected to GP18
buzzer = PWM(Pin(18))

# OLED Screen connected to GP14 (SDA) and GP15 (SCL)
i2c = machine.I2C(1, sda = Pin(14), scl = Pin(15), freq = 400000)
oled = SSD1306_I2C(SCREEN_WIDTH, SCREEN_HEIGHT, i2c)

Andra skillnaden: Picosystems API

Om du skriver kod på Picosystemet måste du skriva inom dess system.

I YouMakeTechs exempel är all spellogik inkapslad i en medan det är sant slinga. Detta inkluderar knappinteraktion, kollisionsdetektering och ritning på skärmen.

I Picosystem måste du skriva inom tre funktioner - init(), update() och dra().

I min kod är all logik i spelet skriven i uppdatera() inklusive kollisionshantering och D-pad-interaktion.

I ett enkelt Pong-spel finns det några funktioner från API:et som jag använde för att underlätta saker och ting:

skärningspunkter(x1, y1, w1, h1, x2, y2, w2, h2)  är förmodligen den största hjälpen här. Du skickar koordinaterna och storleken på de två rutorna och den returnerar true om det finns en skärningspunkt. I det här fallet är de två rektanglarna bollen och stången (även kallad paddel). Bristen med intersects() funktionen är att den inte upptäcker vilken sida kollisionen skedde på, så jag var tvungen att skriva extra kod för att hantera kollisioner på sidan av baren.

Picosystems API kommer att bli riktigt bra när du utvecklar mer komplicerade spel, eftersom det redan har en metod för rambuffertar, ljudutgång, blandning osv. 

Kod för Pimoroni Picosystem Pong-liknande spel

#bar_pos_x = pixels from left, e.g. 0 from left
bar_pos_x = 50
#bar_pos_y = pixels from top, e.g. 100px from top
bar_pos_y = 100
BAR_WIDTH = 30

LENGTH_CONSTANT = 5

ball_speed = 1
ball_pos_x = 10
ball_pos_y = 10
ball_dx = 2
ball_dy = 2

score = 0
game_over = False

def update(tick):
    
    global bar_pos_x
    global bar_pos_y
    global ball_pos_x
    global ball_pos_y
    global ball_dx
    global ball_dy
    global ball_speed
    global score
    global game_over
    
    def reverse_ball_dx():
        global ball_dx
        ball_dx = ball_dx * -1
        
    def reverse_ball_dy():
        global ball_dy
        ball_dy = ball_dy * -1
    
    ball_pos_x += ball_dx
    ball_pos_y += ball_dy
    
    if button(LEFT) and bar_pos_x > 0:
        bar_pos_x -= 1
    
    if button(RIGHT) and bar_pos_x < 120 - BAR_WIDTH :
        bar_pos_x += 1
        
    if ball_pos_x <= 0 :
        ball_pos_x = 0
        reverse_ball_dx()
        
    if ball_pos_x >= 120 - LENGTH_CONSTANT :
        ball_pos_x = 120 - LENGTH_CONSTANT
        reverse_ball_dx()
        
    if ball_pos_y >= 120 - LENGTH_CONSTANT :
        game_over = True
        
    if ball_pos_y <= 0:
        ball_pos_y = 0
        reverse_ball_dy()
        
    if intersects(bar_pos_x,bar_pos_y,BAR_WIDTH,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
        
        reverse_ball_dy()
        score += 10
        
        #main intersection of ball and bar. if they intersect, check if they are intersecting on the sides.
        #if not on sides (i.e. on top) reverse Y direction. Or else, reverse X direction.
        if intersects(bar_pos_x,bar_pos_y,1,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
            
            #intersecting on left
            
            reverse_ball_dx()
            ball_pos_x -= 2
            
        if intersects(bar_pos_x + BAR_WIDTH,bar_pos_y,1,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
            
            #intersecting on right
            
            reverse_ball_dx()
            ball_pos_x += 2

        
def draw(tick):
    
    if game_over:
        pen(0,0,0)
        clear()
        pen(15,15,15)
        text("Game Over", 35, 60)
        
        
    else:
        pen(0, 0, 0)
        clear()
        pen(15,15,15)
    
        #draw bar (paddle)
        frect(bar_pos_x,bar_pos_y,BAR_WIDTH,LENGTH_CONSTANT)
    
        #draw the ball
        frect(ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT)
        text(str(score), 80, 20)
    
start()

Har du ett spel att rekommendera?

Om du har ett spel för Raspberry Pi Pico, lämna en kommentar nedan med en URL.

Och om du vill kolla in vår serie Paragon Projects - gå till här.