Published November 3, 2023 © MIT

DIY Games with Raspberry Pi Pico 🙂🕹️

Welcome to this project where we will be creating an exciting games using MicroPython and Raspberry Pi Pico.

IntermediateFull instructions provided1 hour970

Things used in this project

Hardware components

PCBWay Raspberry Pi Pico

PCBWay Raspberry Pi Pico Case

PCBWay Jumper Wires

PCBWay Breakout Module Shield PS2 Joystick Game Controller

LED Dot Matrix Display, Red

Raspberry Pi Pico USB Cable

Maxim Integrated MAX7219/MAX7221 LED Display Drivers

PCBWay Custom PCB

Software apps and online services

MicroPython

Story

Introduction:

Welcome to this project where I will be creating an exciting games using MicroPython and Raspberry Pi Pico.

In this project, I will connect a joystick controller and an 8x8 LED matrix to the Raspberry Pi Pico to build our games.

The idea for this project came from our love of retro games and our desire to create something fun and interactive using micro python. We wanted to create a game that was simple but challenging, and that could be played by people of all ages.

I chose to use the Raspberry Pi Pico because of its affordability and ease of use. The Pico is a powerful microcontroller that can be programmed using micro python, which is a beginner-friendly language. I also chose to use a joystick and LED matrix because they are simple components that can be easily connected to the Raspberry Pi Pico.

My goal with this project is to inspire others to create their own retro-style games using micro python. I believe that programming can be fun and accessible to everyone, and I hope that this project will encourage more people to explore the world of microcontrollers and game development.

Description:

In this project, we will leverage the power of MicroPython programming language to develop a Ping Pong game and snake game. The Raspberry Pi Pico, a microcontroller board, will serve as the brain of our project. We will connect a joystick controller to the Raspberry Pi Pico, allowing players to control the movement of the paddle in the game or snake movment.

Additionally, we will integrate an 8x8 LED matrix into our setup. This LED matrix will display the game graphics and provide visual feedback during gameplay. By combining these components, we can create an interactive and engaging games experience.

Our journey begins with exploring the capabilities of Raspberry Pi Pico and understanding how to program it using MicroPython. We will set up the necessary development environment and install required libraries for controlling the joystick and LED matrix.

The Project Tools

🛠️ Tools:

If you want to make a PCB for this project or 3D print enclosure, or for any other electronic project, PCBWay is a great choice for you. PCBWay is one of the most experienced PCB manufacturing company in China in field of PCB prototype and fabrication. They provide completed PCB assembly service with worldwide free shipping, and ISO9001 quality control system. Also, on their site there is an online Gift-shop for ordering the tools.

PCBWay has a dedicated component store in addition to PCB services. PCBWay GIFT SHOP is an online marketplace from which we can source all the major electronics stuff, like Raspberry Pi boards, Displays, wires, etc.

https://www.pcbway.com/project/gifts_list

PCBWay has this system that lets us purchase anything from their gift shop with beans. Beans are like redeemable currency or coupons that we get by placing an order on PCBWay or by sharing your projects in the community to get beans.

Raspberry Pi Pico:

The Raspberry Pi Pico is a microcontroller board based on the Raspberry Pi RP2040 microcontroller chip. It has been designed to be a low-cost, high-performance microcontroller board with flexible digital interfaces. The Raspberry Pi Pico features two ARM Cortex-M0+ cores run up to 133MHz; 256KB RAM; 30 GPIO pins; and a broad range of interfacing options. This is paired with 2MB of onboard QSPI Flash memory for code and data storage.

In addition to powerful hardware resources, Pico has rich and complete software support and community resources. It comes with a complete Rasberry Pi official C/C++ SDK, Micropython SDK. Just click https://pico.raspberrypi.org/getting-started/ to get started with Raspberry Pi Pico.

Raspberry Pi Pico

Features:

Raspberry Pi Pico GPIO

Breakout Module Shield PS2 Joystick Game Controller:

Breakout module for analog joystick.
5 pins on board: VCC, GND, X, Y and Button. Connect the module with 5V power suppy with VCC and GND, you can read out the joystick status by X, Y and button pins.
When using the 5V power supply, the default analog output for X, Y is 2.5V. With the direction of the arrow, the voltage up to 5V, and the opposite direction down to 0V.
Package Dimension : 7.62 centimeters L x 5.588 centimeters W x 1.777 centimeters H.

PCBWay Joystick

Wiring a Joystick to Raspberry Pi Pico

Wire the joystick’s 5 pinsto the Pico as follows:

GND to GND (Any GND pin)
+5V to 3V3 Out (physical pin 36). Yes, a 5V joystick will work with the 3V3 power of Pico.
VRx to GP27 / ADC1 (physical pin 32)
VRy to GP26 / ADC0 (physical pin 31)
SW to GP16 (physical pin 21). This would work with most of the GPIo pins.

Wiring a Joystick to Raspberry Pi Pico

An analog thumbstick is effectively three devices in one: a potentiometer for the X axis, a potentiometer for the Y axis and a digital momentary button when you press down.

The internal circuit diagram of the joystick module is shown below:

Circuit Diagram of The Joystick Module

MAX7219 LED Dot Matrix Display with Raspberry Pi Pico:

MAX7219 LED Dot matrix display is one of the popular ones available in the market and used by students, electronics hobbyists, and especially in industrial display applications. There are two types of modules generally available. These are the FC-16 module and the generic module.

Pinout of MAX7219 LED Matrix Module

1 / 3 • Types of MAX7219 Modules

Each module consists of two units. One is the 8X8 LED dot matrix and the other is the MAX7219 IC.

MAX7219 has a built-in BCD decoder that makes it easy to use with seven segment numeric displays. Additionally, it has an 8×8 static RAM that we can use to store numbers. It is one of the most popular displays driver IC.

Some key features of MAX7219 include:

It is an LED driver display IC with a 10MHz serial interface which allows the user to select the decode/No-Decode digit.
Its operation is specified in a voltage range of +4.0 to +5.5V. Normally, the voltage supply of +5V is used.
It provides a feature of digital and analog brightness intensity control and a 150µA shutdown mode in which the current of all segments is pulled to ground.
It consumes very low power.
The data is displayed on segments with a delay time of 2.2ms.
MAX7219 works well in a temperature range of 0°C to +70°C.
The maximum current for each segment pin is 100mA and for each DIGIT ground pin is 500mA.

The input connections of the LED matrix are connected with Raspberry Pi Pico

VCC: This pin supplies power to the MAX7219 module. It is connected with 5V pin of Raspberry Pi Pico.
GND: This is the ground pin which should be connected with the ground pin of Raspberry Pi Pico.
DIN: This is the data in pin. It is used as the SPI input to the module.
CS: This is the Chip Select pin for SPI communication.
CLK: This is called the ‘Serial Clock’ pin which is used in SPI serial clock output.

Snake Game with Raspberry Pi Pico 🐍😀🕹️

The snake algorithm flow diagram is shown below:

Snake Algorithm Flow Diagram

The algorithm I wrote is similar to the previous diagram.

When the game is over, we have stored arrays to display appropriate emojis that you can change 🙂😐😢

When you press the digital momentary button at any moment, it displays the result we have achieved 🧮🙂🕹️🐍️⁉️

1 / 4 • Game Emojis

1 / 2 • Snake and Food

1 / 6 • Game Emojis

Learn more: https://onlinedocs.microchip.com/pr/GUID-57DEB6DD-1115-4A93-9515-41ACCB7164AE-en-US-4/index.html

PingPog Game with Raspberry Pi Pico 🕹️😀🏓

Now, I will dive into designing the game logic. I'll define rules for scoring points, detecting collisions between the ball and paddle, and handling player input from the joystick controller. Through careful coding and testing, we aim to create smooth game-play with responsive controls.

1 / 3 • Ping Pong Game

Below are the steps used:

Step 1) Create two paddles A and B on the left and right side of the screen 🏓

Step 2) Create a ball 🥎

Step 3) Create an event to move the paddle vertically depending on joystick movement 🕹️

Step 4) Create the function to update the score after each player misses a collision 🧮

When you press the digital momentary button at any moment, it displays the player1_score or player2_score that has achieved more points ('A' or '=' or 'B') 🙂⁉️

1 / 3 • player1 wins

Learn more:

https://www.geeksforgeeks.org/create-pong-game-using-python-turtle/

https://almettkidscoding.github.io/basics/pong_game/

Ping Pong game flowchart

Test the Games 🕹️🧐🙌

Pong Game Video

Pico Snake Game Video

Code

"""
MicroPython max7219 cascadable 8x8 LED matrix driver
https://github.com/mcauser/micropython-max7219

MIT License
Copyright (c) 2017 Mike Causer

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""

from micropython import const
import framebuf

_NOOP = const(0)
_DIGIT0 = const(1)
_DECODEMODE = const(9)
_INTENSITY = const(10)
_SCANLIMIT = const(11)
_SHUTDOWN = const(12)
_DISPLAYTEST = const(15)

class Matrix8x8:
    def __init__(self, spi, cs, num):
        """
        Driver for cascading MAX7219 8x8 LED matrices.

        >>> import max7219
        >>> from machine import Pin, SPI
        >>> spi = SPI(1)
        >>> display = max7219.Matrix8x8(spi, Pin('X5'), 4)
        >>> display.text('1234',0,0,1)
        >>> display.show()

        """
        self.spi = spi
        self.cs = cs
        self.cs.init(cs.OUT, True)
        self.buffer = bytearray(8 * num)
        self.num = num
        fb = framebuf.FrameBuffer(self.buffer, 8 * num, 8, framebuf.MONO_HLSB)
        self.framebuf = fb
        # Provide methods for accessing FrameBuffer graphics primitives. This is a workround
        # because inheritance from a native class is currently unsupported.
        # http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
        self.fill = fb.fill  # (col)
        self.pixel = fb.pixel # (x, y[, c])
        self.hline = fb.hline  # (x, y, w, col)
        self.vline = fb.vline  # (x, y, h, col)
        self.line = fb.line  # (x1, y1, x2, y2, col)
        self.rect = fb.rect  # (x, y, w, h, col)
        self.fill_rect = fb.fill_rect  # (x, y, w, h, col)
        self.text = fb.text  # (string, x, y, col=1)
        self.scroll = fb.scroll  # (dx, dy)
        self.blit = fb.blit  # (fbuf, x, y[, key])
        self.init()

    def _write(self, command, data):
        self.cs(0)
        for m in range(self.num):
            self.spi.write(bytearray([command, data]))
        self.cs(1)

    def init(self):
        for command, data in (
            (_SHUTDOWN, 0),
            (_DISPLAYTEST, 0),
            (_SCANLIMIT, 7),
            (_DECODEMODE, 0),
            (_SHUTDOWN, 1),
        ):
            self._write(command, data)

    def brightness(self, value):
        if not 0 <= value <= 15:
            raise ValueError("Brightness out of range")
        self._write(_INTENSITY, value)

    def show(self):
        for y in range(8):
            self.cs(0)
            for m in range(self.num):
                self.spi.write(bytearray([_DIGIT0 + y, self.buffer[(y * self.num) + m]]))
            self.cs(1)

from machine import Pin, PWM, ADC , SPI
from utime import sleep
import max7219
import math
import random
spi = SPI(0,sck=Pin(6),mosi=Pin(7))
CS_PIN = machine.Pin(5, machine.Pin.OUT)
xAxis = ADC(Pin(27))
yAxis = ADC(Pin(26))
button = Pin(22,Pin.IN, Pin.PULL_UP)
display= max7219.Matrix8x8(spi, CS_PIN, 1)
display.brightness(10)
screenWidth=8
screenHeight=8
snakeSize=1
isGameOver=False
tailX=[]
tailY=[]
direction=""
snakeX=4
snakeY=4
foodX=6
foodY=6
eat=False
spd=0.2
def setupFoodPosition():
    global foodX,foodY
    foodX, foodY = random.randrange(0, 7), random.randrange(0, 7)
    
def initSnake():
    tailX.append(snakeX)
    tailY.append(snakeY)
  
def showGameOverScreen():
    for row in range(8):
        for col in range(8):
            if(c>1):
                if face_smile[row][col] == 0:
                    display.pixel(col,row,1)
                else:
                    display.pixel(col,row,0)
                    display.show()
            sleep(0.1)
            if(c<3):
                if face_sad[row][col] == 0:
                    display.pixel(col,row,1)
                else:
                    display.pixel(col,row,0)
                    display.show()
            sleep(0.1)
    sleep(5)
    resetVariables()

def showLed(row, column, c):
    display.pixel(row, column, c)
    display.show()

def resetVariables():
    global direction, isGameOver, snakeSize, spd
    setupSnakePosition()
    setupFoodPosition()
    direction=""
    isGameOver=False
    snakeSize=1
    tailX.clear()
    tailY.clear()
    spd=0.2
    display.fill(0)
    display.show()
    initSnake()

def setupSnakePosition():
    global snakeX,snakeY
    snakeX=4
    snakeY=4

def startGame():
    manageGameOver()
    setJoystickDirection()
    changeSnakeDirection()
    manageSnakeOutOfBounds()
    manageEatenFood()
    manageSnakeTailCoordinates()
    drawSnake()
    sleep(spd)

def manageGameOver():
    global isGameOver
    for i in range(1, snakeSize-1):
        if tailX[i] == snakeX and tailY[i] == snakeY:
            isGameOver=True
    
def setJoystickDirection():
    xValue = xAxis.read_u16()
    yValue = yAxis.read_u16()
    global direction
    if xValue <= 900:
        direction="left"
    elif xValue >= 60000:
        direction="right"
    elif yValue <= 600:
        direction="up"
    elif yValue >= 60000:
        direction="down"
    print(direction)

def changeSnakeDirection():
    global snakeX, snakeY
    if direction == "left":
        snakeX=snakeX-1
    if direction == "right":
        snakeX=snakeX+1
    if direction == "up":
        snakeY=snakeY-1
    if direction == "down":
        snakeY=snakeY+1

def manageSnakeOutOfBounds():
    global snakeX, snakeY
    if snakeX >= screenWidth:
        snakeX=0
    elif snakeX < 0:
        snakeX=screenWidth-1
  
    if snakeY >= screenHeight:
        snakeY=0
    elif snakeY < 0:
        snakeY=screenHeight-1
  
def manageEatenFood():
    global snakeSize, eat
    if snakeX == foodX and snakeY == foodY:
        snakeSize=snakeSize+1
        setupFoodPosition()
        SpeedUp()
        eat=True
    else:
        eat=False
  
def manageSnakeTailCoordinates():
    tailX.insert(0,snakeX)
    tailY.insert(0,snakeY)
    tailIndex = len(tailX)-1
    if eat==False:
        tailX.pop(tailIndex)
        tailY.pop(tailIndex)
  
def drawSnake():
    for i in range(screenHeight):
        for j in range(screenWidth):
            if i == foodY and j == foodX:
                showLed(foodX, foodY, 1)
            else:
                isShown=False
                for idx, item in enumerate(tailX):
                    if tailX[idx]==j and tailY[idx]==i:
                        showLed(tailX[idx], tailY[idx], 1)
                        isShown=True
                if isShown==False:
                    showLed(j, i, 0)

def SpeedUp():
    global spd
    spd -= 0.01
    if spd<0: spd=0

# setupLedBoard
display.brightness(1)   # ajustar brillo 1 a 15
display.fill(1)
display.show()
sleep(0.5)
display.fill(0)
display.show()
sleep(0.2)
setupFoodPosition()
initSnake()
c = 0

face_smile = [
    [1, 1, 1, 1, 1, 1, 1, 1],
    [1, 0, 0, 1, 1, 0, 0, 1],
    [1, 0, 0 ,1 ,1 ,0 ,0 ,1],
    [1 ,0 ,0 ,1 ,1 ,0 ,0 ,1],
    [1 ,1 ,1 ,1 ,1 ,1 ,1 ,1],
    [1 ,0 ,0 ,1 ,1 ,0 ,0 ,1],
    [1,0,0,0,0,0,0 ,1],
    [1 ,1,0,0,0,0,1 ,1]
]
face_sad = [
    [1, 1, 1, 1, 1, 1, 1, 1],
    [1, 0, 0, 1, 1, 0, 0, 1],
    [1, 0, 0 ,1 ,1 ,0 ,0 ,1],
    [1 ,0 ,0 ,1 ,1 ,0 ,0 ,1],
    [1 ,1 ,1 ,1 ,1 ,1 ,1 ,1],
    [1 ,1 ,1 ,1 ,1 ,1 ,1 ,1],
    [1,0,0,0,0,0,0 ,1],
    [1 ,1,1,1,1,1,1 ,1]
]
face_sad1 = [
    [1, 1, 1, 1, 1, 1, 1, 1],
    [1, 0, 0, 1, 1, 0, 0, 1],
    [1, 0, 0 ,1 ,1 ,0 ,0 ,1],
    [1 ,0 ,0 ,1 ,1 ,0 ,0 ,1],
    [1 ,1 ,1 ,1 ,1 ,1 ,1 ,1],
    [1 ,1 ,0 ,0 ,0 ,0 ,1 ,1],
    [1,0,1,1,1,1,0 ,1],
    [0 ,1,1,1,1,1,1 ,0]
]
face_cry = [
    [1, 1, 1, 1, 1, 1, 1, 1],
    [1, 0, 0, 1, 1, 0, 0, 1],
    [1, 0, 0 ,1 ,1 ,0 ,0 ,1],
    [1 ,1 ,1 ,1 ,1 ,1 ,1 ,1],
    [1 ,1 ,1 ,1 ,1 ,1 ,0 ,1],
    [1 ,1 ,1 ,1 ,1 ,1 ,0 ,1],
    [1,1,1,0,0,1,1 ,1],
    [1 ,1,0,1,1,0,1 ,1]
]    
while True:
    buttonValue = button.value()
    if (eat):
        c = c+1
        
    if buttonValue == 0:
        display.fill(0)
        display.text(str(c), 1, 0)
        display.show()
    
    if isGameOver == True:
        showGameOverScreen()
        sleep(1)
    else:
        startGame()

from machine import Pin, PWM, ADC , SPI
import utime
import max7219
import math
# define LED matrix pins
spi = SPI(0,sck=Pin(6),mosi=Pin(7))
CS_PIN = machine.Pin(5, machine.Pin.OUT)
xAxis = ADC(Pin(27))
yAxis = ADC(Pin(26))
button = Pin(22,Pin.IN, Pin.PULL_UP)
# initialize LED matrix
led_matrix = max7219.Matrix8x8(spi, CS_PIN, 1)
led_matrix.brightness(10)
player1_score = 0
player2_score = 0
ball_x = 3
ball_y = 3
ball_vx = 1
ball_vy = 1
paddle1_y = 2
paddle2_y = 2
def update_game():
    global ball_x, ball_y, ball_vx, ball_vy, player1_score, player2_score, paddle1_y, paddle2_y
    
    
    ball_x += ball_vx
    ball_y += ball_vy
    
    
    if ball_y == 0 or ball_y == 7:
        ball_vy = -ball_vy
        
    
    if ball_x == 0 and paddle1_y <= ball_y <= paddle1_y + 2:
        ball_vx = -ball_vx
        
     
    if ball_x == 7 and paddle2_y <= ball_y <= paddle2_y + 2:
        ball_vx = -ball_vx
        
    
    if ball_x == -1:
        player2_score += 1
        ball_x = 3
        ball_y = 3
        

    if ball_x == 8:
        player1_score += 1
        ball_x = 3
        ball_y = 3
        
    
    if button.value() == 0:
        led_matrix.pixel(ball_x, ball_y, 0)


def draw_game():
    global ball_x, ball_y, player1_score, player2_score, paddle1_y, paddle2_y
    
    
    led_matrix.fill(0)
    
    
    led_matrix.pixel(ball_x, ball_y, 1)
    
    
    for i in range(paddle1_y, paddle1_y + 3):
        led_matrix.pixel(0, i, 1)
        
    
    for i in range(paddle2_y, paddle2_y + 3):
        led_matrix.pixel(7, i, 1)
        
    led_matrix.show()

while True:
    xValue = xAxis.read_u16()
    yValue = yAxis.read_u16()
    paddle1_y = xValue //255
    paddle2_y = yValue //255
    update_game()
    draw_game()

    buttonValue = button.value()
    xStatus = "middle"
    yStatus = "middle"
    buttonStatus = "not pressed"
    if xValue <= 900:
        xStatus = "left"
    elif xValue >= 60000:
        xStatus = "right"
    if yValue <= 600:
        yStatus = "up"
    elif yValue >= 60000:
        yStatus = "down"
    if buttonValue == 0:
        
        print(player1_score)
        print(player2_score)
        if(player1_score > player2_score):
            led_matrix.fill(0)
            led_matrix.text('A', 1, 0)
            led_matrix.show()
        elif(player1_score < player2_score):
            led_matrix.fill(0)
            led_matrix.text('B', 1, 0)
            led_matrix.show()
        elif(player1_score == player2_score):
            led_matrix.fill(0)
            led_matrix.text('=', 1, 0)
            led_matrix.show()
        utime.sleep(1)
        
    print("X: " + xStatus + ", Y: " + yStatus + " -- button " + buttonStatus)
    utime.sleep(0.1)