Published March 15, 2017 © CC BY

Count to Pi

How many digits of Pi can you memorize? Put your memory to the test with this game.

IntermediateFull instructions provided1 hour2,258

First Prize

Make:'s Magically Mathematical Pi Day Contest

Things used in this project

Hardware components

Adafruit Standard LCD - 16x2 White on Blue

Also an i2c backpack for this

SparkFun 4x3 Keypad

SparkFun Logic Level Converter - Bi-Directional

Raspberry Pi Zero Wireless

Story

I wanted to make a fun game that could be used to see how many digits of Pi can be memorized. This is the game I came up with using a Raspberry Pi Zero W, 16x2 LCD with an i2c backpack and a 4x3 keypad.

The enclosure

To hold all the parts together nicely I designed an enclosure in Autodesk Fusion 360. I then milled it out on my Shapeoko. You could 3D print it also or just use a cardboard box.

Wiring it up

The keypad has 7 wires that will wire up to the GPIO pins.

Keypad to Raspberry Pi

1 to GPIO 14 (pin 08)

2 to GPIO 15 (pin 10)

3 to GPIO 23 (pin 16)

4 to GPIO 24 (pin 18)

5 to GPIO 8 (pin 24)

6 to GPIO 27 (pin 13)

7 to GPIO 22 (pin 15)

To connect the LCD Display with i2c Backpack we need to use a logic level converter since its 5v and the Pi prefers 3.3V, I followed this guide here.

http://www.raspberrypi-spy.co.uk/2015/05/using-an-i2c-enabled-lcd-screen-with-the-raspberry-pi/

1 / 2

Setting up the Pi Zero W

I used a Pi Zero W so I could easily ssh in to it and modify the code. But if you have a non-wireless Pi zero that will work also.

I loaded a clean image on an sd card, enabled SSH, enable i2c and configured my wireless information.

For interfacing with the keypad we will use pad4pi which can be installed by running this command:

  sudo pip install pad4pi

We will then create a directory for our program:

mkdir countpi

Then put the pi.py, pivalue.ini, and I2C_LCD_driver.py files in that folder.

We also then want to set it up to run the program at boot up automatically. The Pi foundation has some info on how to do it here but I had issues with there guide and did it a tad different.

To edit the rc.local file type:

sudo nano /etc/rc.local

Then scroll down to the bottom and put this in before exit 0:

cd /home/pi/countpi/ 
python pi.py & 
cd ..

Then press ctrl+x and say yes to saving. Now reboot the Pi and you should see it start automatically.

How to play

To power it I used a USB cable powered from my computer. When the Pi boots up the screen should say "let's count to Pi". You can then start entering the digits of Pi, we skip the decimal though.

Once the first row is filled it will go to the 2nd row.

If at any time you enter the wrong number, it will say "game over" and tell you your score.

If you do get a game over you can start a new game by starting to enter Pi again, it will clear the screen and start again. If you make it all the way to the end of the 2nd row you will win the game and see this message.

You can then start a new game same as you would if you lost.

Final

Here's a video of it in action. As you can see, I have quite a few numbers to still memorize.

Thanks for looking over my project. If I didn't explain a part well, just leave me a comment and I will try to help out.

I am quite happy with how this project came out and have a few other ideas using these components in this form. I also think a buzzer would go well with this project.

Schematics

Code

#!/usr/bin/python

import ConfigParser
from pad4pi import rpi_gpio
import time
import os
import I2C_LCD_driver

mylcd = I2C_LCD_driver.lcd()

ROW_PINS = [15,22,27,24] # BCM numbering,
COL_PINS = [23,14,8] # BCM numbering

data = ConfigParser.ConfigParser()
data_file = "pivalue.ini"
data.read(data_file)

current_score = 0
current_digit = 0
lcd_digit = 0

pi = data.get('data', 'pi')

def print_key(key):
    global current_score
    global current_digit
    global lcd_digit
    if (lcd_digit == 0 and current_digit==0):
        mylcd.lcd_clear()
    if str(key) == (pi[current_digit]):
        if current_digit < 16:
            mylcd.lcd_display_string((str(key)), 1, lcd_digit)
            lcd_digit = current_digit + 1
        else:
            lcd_digit = current_digit - 16
            mylcd.lcd_display_string((str(key)), 2, lcd_digit)
        current_digit = current_digit + 1
    else:
        os.system('clear')
        current_score = current_digit
        mylcd.lcd_display_string("Game Over", 1)
	mylcd.lcd_display_string("Score " + str(current_score), 2)
        current_digit = 0
        lcd_digit = 0

    if current_digit == 32:
        mylcd.lcd_clear()
        mylcd.lcd_display_string("You Won", 1)
        mylcd.lcd_display_string("Score " + str(current_score), 2)
        current_digit = 0
        lcd_digit = 0


try:
    factory = rpi_gpio.KeypadFactory()
    keypad = factory.create_keypad(row_pins=ROW_PINS, col_pins=COL_PINS) 

    keypad.registerKeyPressHandler(print_key)

    print("Press buttons on your keypad. Ctrl+C to exit.")
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    print("Goodbye")
finally:
    keypad.cleanup()
    current_digit = 0
    lcd_digit = 0

# -*- coding: utf-8 -*-
# Original code found at:
# https://gist.github.com/DenisFromHR/cc863375a6e19dce359d

"""
Compiled, mashed and generally mutilated 2014-2015 by Denis Pleic
Made available under GNU GENERAL PUBLIC LICENSE

# Modified Python I2C library for Raspberry Pi
# as found on http://www.recantha.co.uk/blog/?p=4849
# Joined existing 'i2c_lib.py' and 'lcddriver.py' into a single library
# added bits and pieces from various sources
# By DenisFromHR (Denis Pleic)
# 2015-02-10, ver 0.1

"""

# i2c bus (0 -- original Pi, 1 -- Rev 2 Pi)
I2CBUS = 1

# LCD Address
ADDRESS = 0x27

import smbus
from time import sleep

class i2c_device:
   def __init__(self, addr, port=I2CBUS):
      self.addr = addr
      self.bus = smbus.SMBus(port)

# Write a single command
   def write_cmd(self, cmd):
      self.bus.write_byte(self.addr, cmd)
      sleep(0.0001)

# Write a command and argument
   def write_cmd_arg(self, cmd, data):
      self.bus.write_byte_data(self.addr, cmd, data)
      sleep(0.0001)

# Write a block of data
   def write_block_data(self, cmd, data):
      self.bus.write_block_data(self.addr, cmd, data)
      sleep(0.0001)

# Read a single byte
   def read(self):
      return self.bus.read_byte(self.addr)

# Read
   def read_data(self, cmd):
      return self.bus.read_byte_data(self.addr, cmd)

# Read a block of data
   def read_block_data(self, cmd):
      return self.bus.read_block_data(self.addr, cmd)


# commands
LCD_CLEARDISPLAY = 0x01
LCD_RETURNHOME = 0x02
LCD_ENTRYMODESET = 0x04
LCD_DISPLAYCONTROL = 0x08
LCD_CURSORSHIFT = 0x10
LCD_FUNCTIONSET = 0x20
LCD_SETCGRAMADDR = 0x40
LCD_SETDDRAMADDR = 0x80

# flags for display entry mode
LCD_ENTRYRIGHT = 0x00
LCD_ENTRYLEFT = 0x02
LCD_ENTRYSHIFTINCREMENT = 0x01
LCD_ENTRYSHIFTDECREMENT = 0x00

# flags for display on/off control
LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00
LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00
LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00

# flags for display/cursor shift
LCD_DISPLAYMOVE = 0x08
LCD_CURSORMOVE = 0x00
LCD_MOVERIGHT = 0x04
LCD_MOVELEFT = 0x00

# flags for function set
LCD_8BITMODE = 0x10
LCD_4BITMODE = 0x00
LCD_2LINE = 0x08
LCD_1LINE = 0x00
LCD_5x10DOTS = 0x04
LCD_5x8DOTS = 0x00

# flags for backlight control
LCD_BACKLIGHT = 0x08
LCD_NOBACKLIGHT = 0x00

En = 0b00000100 # Enable bit
Rw = 0b00000010 # Read/Write bit
Rs = 0b00000001 # Register select bit

class lcd:
   #initializes objects and lcd
   def __init__(self):
      self.lcd_device = i2c_device(ADDRESS)

      self.lcd_write(0x03)
      self.lcd_write(0x03)
      self.lcd_write(0x03)
      self.lcd_write(0x02)

      self.lcd_write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE)
      self.lcd_write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)
      self.lcd_write(LCD_CLEARDISPLAY)
      self.lcd_write(LCD_ENTRYMODESET | LCD_ENTRYLEFT)
      sleep(0.2)


   # clocks EN to latch command
   def lcd_strobe(self, data):
      self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT)
      sleep(.0005)
      self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT))
      sleep(.0001)

   def lcd_write_four_bits(self, data):
      self.lcd_device.write_cmd(data | LCD_BACKLIGHT)
      self.lcd_strobe(data)

   # write a command to lcd
   def lcd_write(self, cmd, mode=0):
      self.lcd_write_four_bits(mode | (cmd & 0xF0))
      self.lcd_write_four_bits(mode | ((cmd << 4) & 0xF0))

   # write a character to lcd (or character rom) 0x09: backlight | RS=DR<
   # works!
   def lcd_write_char(self, charvalue, mode=1):
      self.lcd_write_four_bits(mode | (charvalue & 0xF0))
      self.lcd_write_four_bits(mode | ((charvalue << 4) & 0xF0))
  
   # put string function with optional char positioning
   def lcd_display_string(self, string, line=1, pos=0):
    if line == 1:
      pos_new = pos
    elif line == 2:
      pos_new = 0x40 + pos
    elif line == 3:
      pos_new = 0x14 + pos
    elif line == 4:
      pos_new = 0x54 + pos

    self.lcd_write(0x80 + pos_new)

    for char in string:
      self.lcd_write(ord(char), Rs)

   # clear lcd and set to home
   def lcd_clear(self):
      self.lcd_write(LCD_CLEARDISPLAY)
      self.lcd_write(LCD_RETURNHOME)

   # define backlight on/off (lcd.backlight(1); off= lcd.backlight(0)
   def backlight(self, state): # for state, 1 = on, 0 = off
      if state == 1:
         self.lcd_device.write_cmd(LCD_BACKLIGHT)
      elif state == 0:
         self.lcd_device.write_cmd(LCD_NOBACKLIGHT)

   # add custom characters (0 - 7)
   def lcd_load_custom_chars(self, fontdata):
      self.lcd_write(0x40);
      for char in fontdata:
         for line in char:
            self.lcd_write_char(line)

Credits

Kirby G

3 projects • 22 followers

Comments

Awards

First Prize

Make:'s Magically Mathematical Pi Day Contest

Count to Pi

Things used in this project

Hardware components

Story

The enclosure

Wiring it up

Setting up the Pi Zero W

How to play

Final

Custom parts and enclosures

Design Files

Schematics

Fritzing

Code

Program

Pi value

I2C_LCD_driver.py

Credits

Kirby G

Comments

Awards

Embed the widget on your own site

Count to Pi

Count to Pi

Things used in this project

Hardware components

Story

The enclosure

Wiring it up

Setting up the Pi Zero W

How to play

Final

Custom parts and enclosures

Design Files

Schematics

Fritzing

Code

Program

Pi value

I2C_LCD_driver.py

Credits

Kirby G

Comments

Awards

Related channels and tags