# Simon Game for PyRuler and CircuitPython ## Overview ![](https://cdn-learn.adafruit.com/assets/assets/000/079/401/medium800thumb/leds_covergifsimon.jpg?1565734408) **Simon Says...**"turn that ruler into an interactive memorization game with leds and touch pads!" In this guide you can turn the Adafruit PyRuler into a clone of the [classic game known as Simon](https://en.wikipedia.org/wiki/Simon_(game)) Using CircuitPython, and the PyRuler's leds and capacitive touch pads we can make the PyRuler into our own Simon game. We can program the PyRuler to output patterns to the leds to memorize and then read capacitive touch inputs This guide and code was adapted from [Miguel Grinberg's guide: Simon Game Clone with Circuit Playground Express and CircuitPython](https://learn.adafruit.com/simon-game-clone-with-circuitplayground-express-and-circuitpython) ## Reference guide This is a great guide to use as a reference for all things PyRuler including pinouts, specs and more. - [Adafruit PyRuler](https://learn.adafruit.com/adafruit-pyruler) ## Parts Featured ### Adafruit PyRuler - Engineer Reference Ruler with CircuitPython [Adafruit PyRuler - Engineer Reference Ruler with CircuitPython](https://www.adafruit.com/product/4319) The first time you soldered up a surface mount component you may have been surprised "these are _really small_ parts!" and there's a dozen of different names too! QFN, TDFN, SOIC, SOP, J-Lead, what do they mean and how can you tell how big they are? Now you can have a... In Stock [Buy Now](https://www.adafruit.com/product/4319) [Related Guides to the Product](https://learn.adafruit.com/products/4319/guides) ![A purple-manicured finger presses the capacitive touch pads on a purple electronic ruler. The LEDs light up as the finger presses the capacitive gold pad.](https://cdn-shop.adafruit.com/product-videos/640x480/4319-05.jpg) Featured ### USB cable - USB A to Micro-B [USB cable - USB A to Micro-B](https://www.adafruit.com/product/592) This here is your standard A to micro-B USB cable, for USB 1.1 or 2.0. Perfect for connecting a PC to your Metro, Feather, Raspberry Pi or other dev-board or microcontroller Approximately 3 feet / 1 meter long In Stock [Buy Now](https://www.adafruit.com/product/592) [Related Guides to the Product](https://learn.adafruit.com/products/592/guides) ![USB cable - USB A to Micro-B - 3 foot long](https://cdn-shop.adafruit.com/640x480/592-01.jpg) # Simon Game for PyRuler and CircuitPython ## CircuitPython [CircuitPython](https://github.com/adafruit/circuitpython) is a derivative of [MicroPython](https://micropython.org) designed to simplify experimentation and education on low-cost microcontrollers. It makes it easier than ever to get prototyping by requiring no upfront desktop software downloads. The trinket M0 is the second board that comes pre-loaded with CircuitPython. Simply copy and edit files on the **CIRCUITPY** drive to iterate. Warning: **If you have already plugged in your board, start by ejecting or "safely remove" the CIRCUITPY drive**. This is a good practice to get into. Always eject before unplugging or resetting your board! ## Set up CircuitPython Quick Start! Follow this quick step-by-step for super-fast Python power :) [Download the latest version of CircuitPython for this board via circuitpython.org](https://circuitpython.org/board/pyruler/) **Click the link above and download the latest UF2 file.** Download and save it to your desktop (or wherever is handy). ![adafruit_products_PyRuler_CircuitPython_UF2.png](https://cdn-learn.adafruit.com/assets/assets/000/078/939/medium640/adafruit_products_PyRuler_CircuitPython_UF2.png?1564769605) Plug your PyRuler into your computer using a known-good USB cable. **A lot of people end up using charge-only USB cables and it is very frustrating! So make sure you have a USB cable you know is good for data sync.** Double-click the small **Reset** button next to the Trinket M0 name printed on your board, and you will see the Dotstar RGB LED, noted by the green arrow in the image, turn green. If it turns red, check the USB cable, try another USB port, etc. **Note:** The little LED above the USB connector will be red - this is ok! If double-clicking doesn't work the first time, try again. Sometimes it can take a few tries to get the rhythm right! ![adafruit_products_PyRuler_Status_LED.jpg](https://cdn-learn.adafruit.com/assets/assets/000/078/940/medium640/adafruit_products_PyRuler_Status_LED.jpg?1564770093) You will see a new disk drive appear called **TRINKETBOOT**.       Drag the **adafruit\_circuitpython\_etc.uf2** file to **TRINKETBOOT** ![adafruit_products_PyRuler_TRINKETBOOT.png](https://cdn-learn.adafruit.com/assets/assets/000/078/941/medium640/adafruit_products_PyRuler_TRINKETBOOT.png?1564770430) ![adafruit_products_PyRuler_UF2_Drag.png](https://cdn-learn.adafruit.com/assets/assets/000/078/942/medium640/adafruit_products_PyRuler_UF2_Drag.png?1564770442) The red LED will flash. Then, the **TRINKETBOOT** drive will disappear and a new disk drive called **CIRCUITPY** will appear. That's it, you're done! :) ![adafruit_products_PyRuler_CIRCUITPY.png](https://cdn-learn.adafruit.com/assets/assets/000/078/943/medium640/adafruit_products_PyRuler_CIRCUITPY.png?1564770551) ## Further Information For more detailed info on installing CircuitPython, check out [Installing CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython). # Simon Game for PyRuler and CircuitPython ## Installing the Mu Editor Mu is a simple code editor that works with the Adafruit CircuitPython boards. It's written in Python and works on Windows, MacOS, Linux and Raspberry Pi. The serial console is built right in so you get immediate feedback from your board's serial output! Info: Mu is our recommended editor - please use it (unless you are an experienced coder with a favorite editor already!). While it has been announced end of life in 2026, it still works fine. You are free to use whatever text editor you wish along with a terminal program to connect to the CircuitPython REPL. Thonny is one such editor. ## Download and Install Mu Download Mu from [https://codewith.mu](https://codewith.mu/). Click the  **Download** link for downloads and installation instructions. Click **Start Here ** to find a wealth of other information, including extensive tutorials and and how-to's.   ![circuitpython_WtCP_codewithdotmu_main_page.png](https://cdn-learn.adafruit.com/assets/assets/000/105/677/medium640/circuitpython_WtCP_codewithdotmu_main_page.png?1634749167) Warning: ## Starting Up Mu The first time you start Mu, you will be prompted to select your 'mode' - you can always change your mind later. For now please select **CircuitPython**! The current mode is displayed in the lower right corner of the window, next to the "gear" icon. If the mode says "Microbit" or something else, click the **Mode** button in the upper left, and then choose "CircuitPython" in the dialog box that appears. ![circuitpython_WtCP_Mu_mode_dialogue.png](https://cdn-learn.adafruit.com/assets/assets/000/105/681/medium640/circuitpython_WtCP_Mu_mode_dialogue.png?1634750676) Mu attempts to auto-detect your board on startup, so if you do not have a CircuitPython board plugged in with a **CIRCUITPY** drive available, Mu will inform you where it will store any code you save until you plug in a board. To avoid this warning, plug in a board and ensure that the **CIRCUITPY** drive is mounted before starting Mu. ![circuitpython_WtCP_Mu_device_not_found.png](https://cdn-learn.adafruit.com/assets/assets/000/105/679/medium640/circuitpython_WtCP_Mu_device_not_found.png?1634749722) ## Using Mu You can now explore Mu! The three main sections of the window are labeled below; the button bar, the text editor, and the serial console / REPL. ![](https://cdn-learn.adafruit.com/assets/assets/000/098/505/medium800/circuitpython_Mu_Window_Explained.png?1609970219) Now you're ready to code! Let's keep going... # Simon Game for PyRuler and CircuitPython ## Creating and Editing Code One of the best things about CircuitPython is how simple it is to get code up and running. This section covers how to create and edit your first CircuitPython program. To create and edit code, all you'll need is an editor. There are many options. **Adafruit strongly recommends using Mu! It's designed for CircuitPython, and it's really simple and easy to use, with a built in serial console!** If you don't or can't use Mu, there are a number of other editors that work quite well. The [Recommended Editors page](https://learn.adafruit.com/welcome-to-circuitpython/recommended-editors) has more details. Otherwise, make sure you do "Eject" or "Safe Remove" on Windows or "sync" on Linux after writing a file if you aren't using Mu. (This was formerly not a problem on macOS, but see the warning below.) Warning: macOS Sonoma 14.1 introduced a bug that delays writes to small drives such as CIRCUITPY drives. This caused errors when saving files to CIRCUITPY. There is a [workaround](https://learn.adafruit.com/welcome-to-circuitpython/troubleshooting#macos-sonoma-14-dot-x-disk-errors-writing-to-circuitpy-3160304). The bug was fixed in Sonoma 14.4, but at the cost of greatly slowed writes to drives 1GB or smaller. ## Creating Code Installing CircuitPython generates a **code.py** file on your **CIRCUITPY** drive. To begin your own program, open your editor, and load the **code.py** file from the **CIRCUITPY** drive. If you are using Mu, click the **Load** button in the button bar, navigate to the **CIRCUITPY** drive, and choose **code.py**. ![circuitpython_WtCP_Mu_open_code_py.png](https://cdn-learn.adafruit.com/assets/assets/000/105/703/medium640/circuitpython_WtCP_Mu_open_code_py.png?1634763740) Copy and paste the following code into your editor: ```python import board import digitalio import time led = digitalio.DigitalInOut(board.LED) led.direction = digitalio.Direction.OUTPUT while True: led.value = True time.sleep(0.5) led.value = False time.sleep(0.5) ``` Danger: The KB2040, QT Py , Qualia, and the Trinkeys do not have a built-in little red LED! There is an addressable RGB NeoPixel LED. The above example will NOT work on the KB2040, QT Py, Qualia, or the Trinkeys! If you're using a KB2040, QT Py, Quaila, or a Trinkey, or any other board without a single-color LED that can blink, please download the [NeoPixel blink example](https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/master/Welcome_to_CircuitPython/code.py). Info: It will look like this. Note that under the `while True:` line, the next four lines begin with four spaces to indent them, and they're indented exactly the same amount. All the lines before that have no spaces before the text. ![circuitpython_WtCP_Mu_blink_example.png](https://cdn-learn.adafruit.com/assets/assets/000/105/704/medium640/circuitpython_WtCP_Mu_blink_example.png?1634763853) Save the **code.py** file on your **CIRCUITPY** drive. ![circuitpython_WtCP_Mu_save_bliink_example.png](https://cdn-learn.adafruit.com/assets/assets/000/105/705/medium640/circuitpython_WtCP_Mu_save_bliink_example.png?1634763954) The little LED should now be blinking. Once per half-second. Congratulations, you've just run your first CircuitPython program! Info: On most boards you'll find a tiny red LED. On the ItsyBitsy nRF52840, you'll find a tiny blue LED. On QT Py M0, QT Py RP2040, Qualia, and the Trinkey series, you will find only an RGB NeoPixel LED. ## Editing Code To edit code, open the  **code.py**  file on your **CIRCUITPY** drive into your editor.   Make the desired changes to your code. Save the file. That's it! ![circuitpython_WtCP_Mu_open_code_py.png](https://cdn-learn.adafruit.com/assets/assets/000/105/706/medium640/circuitpython_WtCP_Mu_open_code_py.png?1634764153) ### Your code changes are run as soon as the file is done saving. There's one warning before you continue... Danger: The CircuitPython code on your board detects when the files are changed or written and will automatically re-start your code. This makes coding very fast because you save, and it re-runs. If you unplug or reset the board before your computer finishes writing the file to your board, you can corrupt the drive. If this happens, you may lose the code you've written, so it's important to backup your code to your computer regularly. There are a couple of ways to avoid filesystem corruption. ### **1. Use an editor that writes out the file completely when you save it.** Check out the [Recommended Editors page](https://learn.adafruit.com/welcome-to-circuitpython/recommended-editors) for details on different editing options. Info: ### **2. Eject or Sync the Drive After Writing** If you are using one of our not-recommended-editors, not all is lost! You can still make it work. On Windows, you can Eject or Safe Remove the **CIRCUITPY** drive. It won't actually eject, but it will force the operating system to save your file to disk. On Linux, use the **sync** command in a terminal to force the write to disk. You also need to do this if you use Windows Explorer or a Linux graphical file manager to drag a file onto **CIRCUITPY**. ### Don't worry! Corrupting the drive isn't the end of the world (or your board!). If this happens, follow the steps found on the [Troubleshooting](https://learn.adafruit.com/welcome-to-circuitpython/troubleshooting) page of every board guide to get your board up and running again. Info: If you are having trouble saving code on Windows 10, try including this code snippet at the top of code.py: ```python import supervisor supervisor.runtime.autoreload = False ``` ## Back to Editing Code... Now! Let's try editing the program you added to your board. Open your **code.py** file into your editor. You'll make a simple change. Change the first `0.5` to `0.1`. The code should look like this: ```python import board import digitalio import time led = digitalio.DigitalInOut(board.LED) led.direction = digitalio.Direction.OUTPUT while True: led.value = True time.sleep(0.1) led.value = False time.sleep(0.5) ``` Leave the rest of the code as-is. Save your file. See what happens to the LED on your board? Something changed! Do you know why? You don't have to stop there! Let's keep going. Change the second `0.5` to `0.1` so it looks like this: ```auto while True: led.value = True time.sleep(0.1) led.value = False time.sleep(0.1) ``` Now it blinks really fast! You decreased the both time that the code leaves the LED on and off! Now try increasing both of the `0.1` to `1`. Your LED will blink much more slowly because you've increased the amount of time that the LED is turned on and off. Well done! You're doing great! You're ready to start into new examples and edit them to see what happens! These were simple changes, but major changes are done using the same process. Make your desired change, save it, and get the results. That's really all there is to it! # Naming Your Program File CircuitPython looks for a code file on the board to run. There are four options: **code.txt** , **code.py** , **main.txt** and **main.py**. CircuitPython looks for those files, in that order, and then runs the first one it finds. While **code.py** is the recommended name for your code file, it is important to know that the other options exist. If your program doesn't seem to be updating as you work, make sure you haven't created another code file that's being read instead of the one you're working on. # Simon Game for PyRuler and CircuitPython ## Code PyRuler with CircuitPython ## Installing Project Code To use with CircuitPython, you need to first install a few libraries, into the lib folder on your **CIRCUITPY** drive. Then you need to update **code.py** with the example script. Thankfully, we can do this in one go. In the example below, click the **Download Project Bundle** button below to download the necessary libraries and the **code.py** file in a zip file. Extract the contents of the zip file, open the directory **PyRuler\_Simon\_Game/** and then click on the directory that matches the version of CircuitPython you're using and copy the contents of that directory to your **CIRCUITPY** drive. Your **CIRCUITPY** drive should now look similar to the following image: ![CIRCUITPY](https://adafruit.github.io/Adafruit_Learning_System_Guides/PyRuler_Simon_Game.png ) https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/PyRuler_Simon_Game/code.py # Simon Game for PyRuler and CircuitPython ## How Simon Works ## Game play ![](https://cdn-learn.adafruit.com/assets/assets/000/079/442/medium800thumb/leds_howto1gif.jpg?1565813780) To play the Simon game, power up the PyRuler by plugging in a USB cable connected to a computer or a USB cell phone battery. You will see the 4 leds above each touch pad light up in sequence then turn off. Next, you will see one of the 4 leds turn on and off. Then the DotStar RGB LED on the Trinket-sized circuit board will turn green prompting you to touch the pad corresponding to the led that was just on. If you correctly input the given pattern, the DotStar led will cycle through a random pattern and the next pattern will be shown. ![](https://cdn-learn.adafruit.com/assets/assets/000/079/443/medium800thumb/leds_howtogif2.jpg?1565813941) Each future pattern has the same initial sequence from before with one more added to the sequence each time. When the DotStar is blue, the program is showing you the sequence. If you get a sequence wrong, the DotStar will turn red then the game will start over with the leds cycling through the intro pattern. ## How the code works Here's what's going on behind the scenes to deliver you the Simon game you know and love. ## Initialization This segment towards the beginning of the program initializes the 4 touch pads on the PyRuler as well as the corresponding 4 leds. ```auto touches = [DigitalInOut(board.CAP0)] for p in (board.CAP1, board.CAP2, board.CAP3): touches.append(touchio.TouchIn(p)) leds = [] for p in (board.LED4, board.LED5, board.LED6, board.LED7): led = DigitalInOut(p) led.direction = Direction.OUTPUT leds.append(led) cap_touches = [False, False, False, False] ``` ## Functions These functions simplify and optimize how the program runs. ## DotStar code This part shows how the rainbow pattern for the dot star works. ```auto def wheel(pos): # Input a value 0 to 255 to get a color value. # The colours are a transition r - g - b - back to r. if pos < 0 or pos > 255: return (0, 0, 0) if pos < 85: return (255 - pos * 3, pos * 3, 0) if pos < 170: pos -= 85 return (0, 255 - pos * 3, pos * 3) pos -= 170 return (pos * 3, 0, 255 - pos * 3) def rainbow_cycle(wait): for j in range(255): for i in range(len(pixels)): rc_index = (i * 256 // len(pixels)) + j pixels[i] = wheel(rc_index & 255) time.sleep(wait) ``` ## Detecting capacitive touch and setting a timer Up next we read input from the PyRuler capacitive touch pads with the `read_caps()` function. Then with the `timeout_touch()` function we set a 3 second timer after each pattern is displayed as well as in-between each touch. ```auto def read_caps(): t0_count = 0 t0 = touches[0] t0.direction = Direction.OUTPUT t0.value = True t0.direction = Direction.INPUT # funky idea but we can 'diy' the one non-hardware captouch device by hand # by reading the drooping voltage on a tri-state pin. t0_count = t0.value + t0.value + t0.value + t0.value + t0.value + \ t0.value + t0.value + t0.value + t0.value + t0.value + \ t0.value + t0.value + t0.value + t0.value + t0.value cap_touches[0] = t0_count > 2 cap_touches[1] = touches[1].raw_value > 3000 cap_touches[2] = touches[2].raw_value > 3000 cap_touches[3] = touches[3].raw_value > 3000 return cap_touches def timeout_touch(timeout=3): start_time = time.monotonic() # start 3 second timer waiting for user input while time.monotonic() - start_time < timeout: caps = read_caps() for i,c in enumerate(caps): if c: return i ``` ## Playing and reading each sequence with leds - `light_cap()` turns on the led associated with each touch pad if the pad was touched. - `play_sequence()` plays each led for the given sequence and slowly speeds up the playback of each sequence as they get longer. - `read_sequence()` First turns the DotStar green (indicating to user to enter the sequence) then reads the touch pads and determines if they are the right sequence. If the wrong pad was touched, the function returns `False` which will cause a game over (more on this later). ```auto def light_cap(cap, duration=0.5): # turn the LED for the selected cap on leds[cap].value = True time.sleep(duration) leds[cap].value = False time.sleep(duration) def play_sequence(seq): duration = max(0.1, 1 - len(sequence) * 0.05) for cap in seq: light_cap(cap, duration) def read_sequence(seq): pixels.fill(green) for cap in seq: if timeout_touch() != cap: # the player made a mistake! return False light_cap(cap, 0.5) return True ``` ## The main loop - First trigger the starting sequence of leds demonstrating the game is beginning. - Next in a nested loop, turn the DotStar blue demonstrating the sequence is being shown. - Then add a random number between 0 and 3 to the sequence and play the sequence.  - If the user enters the wrong sequence or the time runs out, turn the DotStar red indicating game over, and exit the loop starting the game over at the top of the main loop. - Otherwise, trigger the rainbow animation on the DotStar (indicating a correct sequence) and move to next sequence. ```auto while True: # led light sequence at beginning of each game pixels.fill(blue) time.sleep(1) for led in leds: led.value = True time.sleep(0.25) for led in leds: led.value = False sequence = [] while True: pixels.fill(blue) # blue for showing user sequence time.sleep(1) sequence.append(random.randint(0, 3)) # add new light to sequence each time play_sequence(sequence) # show the sequence if not read_sequence(sequence): # if user inputs wrong sequence, gameover # game over, make dot star red pixels.fill(red) time.sleep(3) print("gameover") break else: print("Next sequence unlocked!") rainbow_cycle(0) # Dot star animation after each correct sequence pixels.fill(0) time.sleep(1) ``` That's it, now you're a CircuitPython wiz! Simon Says time to make your own game with the PyRuler! ## Guide Products ### Adafruit PyRuler - Engineer Reference Ruler with CircuitPython [Adafruit PyRuler - Engineer Reference Ruler with CircuitPython](https://www.adafruit.com/product/4319) The first time you soldered up a surface mount component you may have been surprised "these are _really small_ parts!" and there's a dozen of different names too! QFN, TDFN, SOIC, SOP, J-Lead, what do they mean and how can you tell how big they are? Now you can have a... In Stock [Buy Now](https://www.adafruit.com/product/4319) [Related Guides to the Product](https://learn.adafruit.com/products/4319/guides) ### USB cable - USB A to Micro-B [USB cable - USB A to Micro-B](https://www.adafruit.com/product/592) This here is your standard A to micro-B USB cable, for USB 1.1 or 2.0. Perfect for connecting a PC to your Metro, Feather, Raspberry Pi or other dev-board or microcontroller Approximately 3 feet / 1 meter long In Stock [Buy Now](https://www.adafruit.com/product/592) [Related Guides to the Product](https://learn.adafruit.com/products/592/guides) ## Related Guides - [Adafruit PyRuler](https://learn.adafruit.com/adafruit-pyruler.md) - [NeoTrellis M4 MIDI File Synthesizer](https://learn.adafruit.com/neotrellism4-midi-file-player-synthesizer.md) - [PyPortal LIFX Lighting Controller ](https://learn.adafruit.com/pyportal-lifx-lighting-controller.md) - [Bluetooth Cycling Speed & Cadence Sensor Display with Clue](https://learn.adafruit.com/bluetooth-bicycle-speed-cadence-sensor-display-with-clue.md) - [Quickstart - Raspberry Pi RP2040 with BLE and CircuitPython](https://learn.adafruit.com/quickstart-raspberry-pi-rp2040-with-ble-and-circuitpython.md) - [Interactive Map with Circuit Playground Express](https://learn.adafruit.com/interactive-map-with-cpx.md) - [Simon Game Clone with Circuit Playground Express and CircuitPython](https://learn.adafruit.com/simon-game-clone-with-circuitplayground-express-and-circuitpython.md) - [NeoPixel Badge Lanyard with Bluetooth LE](https://learn.adafruit.com/bluetooth-neopixel-badge-lanyard.md) - [Glue Stick Light Pipe Sculpture](https://learn.adafruit.com/glue-stick-archway.md) - [Crawling Baby Sea Turtle Robot](https://learn.adafruit.com/baby-turtle-makecode.md) - [Clue Coffee Scale](https://learn.adafruit.com/clue-coffee-scale.md) - [CLUE Rock, Paper, Scissors Game using Bluetooth](https://learn.adafruit.com/rock-paper-scissors-circuitpython.md) - [Halloween Countdown Display Matrix](https://learn.adafruit.com/halloween-countdown-display-matrix.md) - [Halloween Sentry-Bot with CRICKIT for CPX](https://learn.adafruit.com/halloween-sentry-bot.md) - [Using the Bluefruit Dashboard with Web Bluetooth in Chrome](https://learn.adafruit.com/bluefruit-dashboard-web-bluetooth-chrome.md) - [Circuit Playground-O-Phonor](https://learn.adafruit.com/circuit-playground-o-phonor.md)