# PyBadge Conference Badge With Unicode Fonts
## Overview
Get ready for your next conference with the PyBadge Conference Badge. With this simple project, not only can you show off some of your basic details for people to contact you, but you can also control the NeoPixels at the bottom to draw people's attention to your badge.
This project displays a simple name tag that is drawn using code, so it is easy to customize without the need to do any graphical editing. Additionally, since CircuitPython is capable of displaying unicode, fonts are very customizable.
## Parts
### Adafruit PyBadge for MakeCode Arcade, CircuitPython, or Arduino
[Adafruit PyBadge for MakeCode Arcade, CircuitPython, or Arduino](https://www.adafruit.com/product/4200)
What's the size of a credit card and can run CircuitPython, MakeCode Arcade or Arduino? That's right, its the **Adafruit PyBadge!** We wanted to see how much we could cram into a 3 3⁄8 × 2 1⁄8 inch rounded rectangle, to make an all-in-one dev board with...
Out of Stock
[Buy Now](https://www.adafruit.com/product/4200)
[Related Guides to the Product](https://learn.adafruit.com/products/4200/guides)
### Adafruit PyBadge LC - MakeCode Arcade, CircuitPython, or Arduino
[Adafruit PyBadge LC - MakeCode Arcade, CircuitPython, or Arduino](https://www.adafruit.com/product/3939)
What's the size of a credit card and can run CircuitPython, MakeCode Arcade or Arduino even when you're on a budget? That's right, it's the **Adafruit PyBadge LC!** We wanted to see how much we could cram into a 3 3⁄8 × 2 1⁄8 inch...
In Stock
[Buy Now](https://www.adafruit.com/product/3939)
[Related Guides to the Product](https://learn.adafruit.com/products/3939/guides)
### Accessories
Be sure to grab a lanyard so you can easily show off your badge.
### Adafruit Circuit Playground Lanyard
[Adafruit Circuit Playground Lanyard](https://www.adafruit.com/product/3987)
We've got our Circuit Playground friends on [lunchboxes](https://www.adafruit.com/product/3437), [posters](https://www.adafruit.com/?q=posters), [puzzle](https://www.adafruit.com/product/3817),
In Stock
[Buy Now](https://www.adafruit.com/product/3987)
[Related Guides to the Product](https://learn.adafruit.com/products/3987/guides)
This project doesn't use the speaker, but they're inexpensive and very easy to add in case you decide to get creative and add sound.
### Mini Oval Speaker - 8 Ohm 1 Watt
[Mini Oval Speaker - 8 Ohm 1 Watt](https://www.adafruit.com/product/3923)
Hear the good news! This wee speaker is a great addition to any audio project where you need 8 ohm impedance and 1W or less of power. We particularly like this speaker as it is small and comes with nice skinny wires with a connector on the end. It has a handy...
In Stock
[Buy Now](https://www.adafruit.com/product/3923)
[Related Guides to the Product](https://learn.adafruit.com/products/3923/guides)
Also, be sure to pick up a couple of batteries in case they get low on power so you can just swap them out. The PyBadge comes with built-in charging circuitry, so they're very easy to charge.
### Lithium Ion Polymer Battery Ideal For Feathers - 3.7V 400mAh
[Lithium Ion Polymer Battery Ideal For Feathers - 3.7V 400mAh](https://www.adafruit.com/product/3898)
Lithium-ion polymer (also known as 'lipo' or 'lipoly') batteries are thin, light, and powerful. The output ranges from 4.2V when completely charged to 3.7V. This battery has a capacity of **400mAh** for a total of about 1.9 Wh. If you need a larger (or smaller!)...
In Stock
[Buy Now](https://www.adafruit.com/product/3898)
[Related Guides to the Product](https://learn.adafruit.com/products/3898/guides)
# PyBadge Conference Badge With Unicode Fonts
## Setup
To get set up, we will need CircuitPython, a few libraries and the Conference Badge Source Code and fonts downloaded from Github.
## Required CircuitPython Libraries
First, make sure you are running the [latest version of Adafruit CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython) for your board.
Next, you'll need to install the necessary libraries to use the hardware--carefully follow the steps to find and install these libraries from [Adafruit's CircuitPython library bundle](https://github.com/adafruit/Adafruit_CircuitPython_Bundle). Our introduction guide has [a great page on how to install the library bundle](https://learn.adafruit.com/welcome-to-circuitpython/circuitpython-libraries) for both express and non-express boards.
Since the fonts take up a good deal of space, Adafruit recommends that you manually install only the necessary libraries from the bundle:
- **neopixel**
- **adafruit\_bitmap\_font**
- **adafruit\_display\_shapes**
- **adafruit\_display\_text**
Before continuing make sure your board's lib folder or root filesystem have the **neopixel** , **adafruit\_bitmap\_font** , **adafruit\_display\_shapes** , and **adafruit\_display\_text** files and folders copied over.
## Conference Badge Source Code
Next, we'll continue by downloading the Source Code from Github.
[Conference Badge Source Code](https://github.com/adafruit/Adafruit_Learning_System_Guides/tree/master/PyBadge_Conference_Badge)
The fonts go in a subdirectory of your PyBadge's main **CIRCUITPY** flash drive named **/fonts**.
Here is the CircuitPython code in its entirety. If you click on Download Project Zip, it will download the fonts used in this tutorial also.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/PyBadge_Conference_Badge/code.py
After copying everything over, your PyBadge should display a Nametag with Blinka on it and the neopixels should animate. In the next few sections, we'll go over the Fonts and how to make changes.
# PyBadge Conference Badge With Unicode Fonts
## Multilingual Fonts
In order to provide as much language support in a single font, we looked at quite a few different ones. We decided to choose one of the Google Noto fonts. The specific font is the Noto Sans Display font due to its ability to support over 500 languages through its support of the Latin, Greek, and Cyrillic character sets. It is called a Noto Font because the goal of the font was to avoid needing to display the placeholder blocks that represent the missing characters. These placeholder blocks are referred to as "Tofu", so the name of the font is short for No Tofu.
If you would like to make your own custom font, be sure to check out our [Custom Fonts for CircuitPython Displays guide](https://learn.adafruit.com/custom-fonts-for-pyportal-circuitpython-display). For the fonts in this guide, we used otf2bdf.
For the basic Badge, we have a simple Hello, My Name Is Blinka. You can change the name "Blinka" to whatever your name is.
But what if your name has non-English characters? If your name has accents, that's easy since the Noto font has all of the accented characters. But let's say Blinka happened to be from Greece and had Greek characters. CircuitPython will handle this with no problems.
That's because CircuitPython handles unicode. In this case since Blinka isn't normally composed of Greek characters, we chose some equivalent Greek characters to demonstrate the badge's ability to display Greek. But what about Cyrillic characters like Russian? Yes, no problem.
## Other Character Sets
Warning:
Ok, so we know we can write out the name in many languages just with these three character sets. If you have a name that uses another character set such as Arabic, Thai, Korean, Japanese or Chinese, there are plenty more font sets available from Google. In fact they have a page where you can type in your language and it will show you the fonts they have available in that language.
[Google Noto Fonts](https://www.google.com/get/noto/)
Of course you aren't limited to these fonts. You may find other font sets are much smaller and fit into the memory space on the PyBadge better. Here's an example of a Japanese Font with only katakana characters.
CircuitPython is even capable of handling fonts that should display Right to Left, with a small caveat. You will need to reverse the string before displaying it. You can easily do this with the following line of code.
```auto
NAME_STRING = ''.join(reversed(NAME_STRING))
```
Afterwards, it should display similar to this name tag that displays Blinka in Hebrew.
## Changing the Hello Message
What if you would like to change the Hello message on the Badge? Yes, you can easily do that. Let's say we have a French Blinka.
We can easily change the labels to say the equivalent message in French.
Now let's take a look at some other customizations we can do to the badge on the following pages.
# PyBadge Conference Badge With Unicode Fonts
## Customizing the Name Tag
The name tag can be customized in a number of ways. Let's take a look at the easiest option to change first.
## Basic Customizations
```auto
HELLO_STRING = "HELLO"
MY_NAME_STRING = "MY NAME IS"
NAME_STRING = "Blinka"
NAME_FONTNAME = "/fonts/Noto-18.bdf"
NEOPIXEL_COUNT = 5
BACKGROUND_COLOR = 0xFF0000
FOREGROUND_COLOR = 0xFFFFFF
BACKGROUND_TEXT_COLOR = 0xFFFFFF
FOREGROUND_TEXT_COLOR = 0x000000
```
The most obvious customization is changing your name. Just edit `NAME_STRING`. You can even us a `\n` newline character in the middle of your string to break your information into two lines. The text will automatically center both horizontally and vertically. You can also change the message at the top by editing `HELLO_STRING` and `MY_NAME_STRING`.
The next items to change are the colors of the badge. Colors are Hexadecimal values in the format of RRGGBB. For instance, you can change the red `BACKGROUND_COLOR`, which is currently 0xFF0000, to anything you like as well as the white `FOREGROUND_COLOR`.
For instance, if we set `BACKGROUND_COLOR` to 0x0000FF, which is Blue and`FOREGROUND_COLOR` to 0xFFFF00, which is yellow, the result would look something like this.
You can also easily set the `BACKGROUND_TEXT_COLOR` to change the text on top of the red background or the `FOREGROUND_TEXT_COLOR` to change the color of your name.
If you have a custom font that you would like to use, you can set it by changing the `NAME_FONTNAME` to correct path.
The last item here that you can change is the `NEOPIXEL_COUNT`. If you have one of the PyBadge LC models with only one NeoPixel, you will want to change this to `1`.
## Advanced Customizations
Additionally, you can change anything else you want in this name tag which includes:
- The fonts of the other labels
- Positions of all the labels
- Individual colors of the labels
- Adding graphics
- Storing and loading the current settings from non-volatile memory
- Anything else you can think of
# PyBadge Conference Badge With Unicode Fonts
## Using the NeoPixels
Since the badge has built-in NeoPixels, let's animate them.
Now let's take a look at the code that does the animation.
## CircuitPython NeoPixel Code
```python
brightness = 0.2
direction = 1
speed = 1
# Define the NeoPixel
neopixels = neopixel.NeoPixel(
board.NEOPIXEL,
NEOPIXEL_COUNT,
brightness=settings["brightness"],
auto_write=False,
pixel_order=neopixel.GRB,
)
# Remap the calculated rotation to 0 - 255
def remap(vector):
return int(((255 * vector + 85) * 0.75) + 0.5)
# Calculate the Hue rotation starting with Red as 0 degrees
def rotate(degrees):
cosA = cos(radians(degrees))
sinA = sin(radians(degrees))
red = cosA + (1.0 - cosA) / 3.0
green = 1./3. * (1.0 - cosA) + sqrt(1./3.) * sinA
blue = 1./3. * (1.0 - cosA) - sqrt(1./3.) * sinA
return (remap(red), remap(green), remap(blue))
palette = []
pixels = []
# Generate a rainbow palette
for degree in range(0, 360):
color = rotate(degree)
palette.append(color[0] << 16 | color[1] << 8 | color[2])
# Create the Pattern
for x in range(0, NEOPIXEL_COUNT):
pixels.append(x * 360 // NEOPIXEL_COUNT)
while True:
for color in range(0, 360, speed):
for index in range(0, NEOPIXEL_COUNT):
palette_index = pixels[index] + color * direction
if palette_index >= 360:
palette_index -= 360
elif palette_index < 0:
palette_index += 360
neopixels[index] = palette[palette_index]
neopixels.show()
neopixels.brightness = brightness
```
This can be broken down. Let's look at each section.
We will begin by including `NEOPIXEL_COUNT`, which was discussed in the previous section. Next, we set the default brightness, which is a `float` value between 0.0 and 1.0, the direction which will be either 1 or -1, and the speed which has to be a positive `int`or integer. Finally, we define the NeoPixel object.
```python
NEOPIXEL_COUNT = 5
brightness = 0.2
direction = 1
speed = 1
# Define the NeoPixel
neopixels = neopixel.NeoPixel(
board.NEOPIXEL,
NEOPIXEL_COUNT,
brightness=settings["brightness"],
auto_write=False,
pixel_order=neopixel.GRB,
)
```
In the next section we define a couple of functions that do the math for generating the rainbow palette. The `rotate()` function does most of the work and takes in a number between 0 and 360 degrees, with 0 degrees being red, and performs calculations to get the red, blue, and green component values. The values are then remapped with the `remap()` function to be between 0 and 255.
```auto
# Remap the calculated rotation to 0 - 255
def remap(vector):
return int(((255 * vector + 85) * 0.75) + 0.5)
# Calculate the Hue rotation starting with Red as 0 degrees
def rotate(degrees):
cosA = cos(radians(degrees))
sinA = sin(radians(degrees))
red = cosA + (1.0 - cosA) / 3.0
green = 1./3. * (1.0 - cosA) + sqrt(1./3.) * sinA
blue = 1./3. * (1.0 - cosA) - sqrt(1./3.) * sinA
return (remap(red), remap(green), remap(blue))
```
In the next section, we pre-calculate the red, blue, and green components of each of the colors so that we don't need to do as much math during the animation sequence and add them into a palette array. For the pattern, we are really just trying to choose some numbers that are distributed evenly.
```python
palette = []
pixels = []
# Generate a rainbow palette
for degree in range(0, 360):
color = rotate(degree)
palette.append(color[0] << 16 | color[1] << 8 | color[2])
# Create the Pattern
for x in range(0, NEOPIXEL_COUNT):
pixels.append(x * 360 // NEOPIXEL_COUNT)
```
Finally, we get to the main loop and do a simple palette rotation. We do this by going through all of the degrees in the color wheel. Depending on the speed, we may skip a few steps to make it go faster. We simply need to get the index of the color we want in the palette that we had pre-calculated.
We can change the direction by making the index a negative number, which is then adjusted to be within the range of 0-360 and we have our index. We look up the color by providing the index to the palette and then assign the color to the neopixel.
We also set the brightness of the NeoPixels here in case we changed it.
```python
while True:
for color in range(0, 360, speed):
for index in range(0, NEOPIXEL_COUNT):
palette_index = pixels[index] + color * direction
if palette_index >= 360:
palette_index -= 360
elif palette_index < 0:
palette_index += 360
neopixels[index] = palette[palette_index]
neopixels.show()
neopixels.brightness = brightness
```
# PyBadge Conference Badge With Unicode Fonts
## PyBadge Buttons
To use the PyBadge buttons, we will need a few pieces of code. Here's how the buttons function:
- Pushing **Up** make the lights cycle faster
- Pushing **Down** makes the lights cycle slower
- Pushing **Right** makes the lights appear to move to the right
- Pushing **Left** makes the buttons appear to move to the left
- Pushing the **B Button** makes the lights dimmer
- Pushing the **A Button** makes the light brighter
## CircuitPython Button Code
```python
BUTTON_LEFT = const(7)
BUTTON_UP = const(6)
BUTTON_DOWN = const(5)
BUTTON_RIGHT = const(4)
BUTTON_SEL = const(3)
BUTTON_START = const(2)
BUTTON_A = const(1)
BUTTON_B = const(0)
# Define Events and Shift Register
latest_event = Event()
last_event = Event()
pad = ShiftRegisterKeys(clock=board.BUTTON_CLOCK,
data=board.BUTTON_OUT,
latch=board.BUTTON_LATCH,
key_count=8,
value_when_pressed=True,
interval=0.1,
max_events=1)
def check_buttons(event):
if event.key_number == BUTTON_RIGHT:
settings["direction"] = -1
elif event.key_number == BUTTON_LEFT:
settings["direction"] = 1
elif (event.key_number == BUTTON_UP) and settings["speed"] < 10:
settings["speed"] += 1
elif (event.key_number == BUTTON_DOWN) and settings["speed"] > 1:
settings["speed"] -= 1
elif (event.key_number == BUTTON_A) and settings["brightness"] < 0.5:
settings["brightness"] += 0.025
elif (event.key_number == BUTTON_B) and settings["brightness"] > 0.025:
settings["brightness"] -= 0.025
last_read = 0
while True:
for color in range(0, 360, speed):
pad.events.get_into(latest_event)
if latest_event.pressed and latest_event.key_number != last_event.key_number:
check_buttons(latest_event)
last_event = latest_event
latest_event = Event(
key_number=8
) # An imaginary key number that doesn't exist!
```
This code uses ShiftRegisterKeys, which allows reading the state of the buttons from the internal shift register. This means we need to detect when a button is pressed and released. We do this by monitoring the state of all the buttons and respond only when there is a change. Let's look at the code a little closer.
```auto
BUTTON_LEFT = const(7)
BUTTON_UP = const(6)
BUTTON_DOWN = const(5)
BUTTON_RIGHT = const(4)
BUTTON_SEL = const(3)
BUTTON_START = const(2)
BUTTON_A = const(1)
BUTTON_B = const(0)
```
There are eight buttons on the PyBadge and each corresponds to the position of a bit in the byte of data that is returned. In the first part, we define which button corresponds to the appropriate value. We do that by defining each of the buttons as bit masks. Bit masking works by defining which bits we want to look at and which we want to hide or "mask". For instance we have `BUTTON_SEL` defined as 3, which is bit 3 in an 8-bit array, so it looks for `0x00001000` in binary.
If ShiftRegisterKeys gets back a value that is something like `0x01001000` then it knows that the `BUTTON_SEL` is being pressed at the same time as `BUTTON_UP` which is bit 7 or `0x01000000`.
In the next segment of code we create a couple of `Event` objects and setup the `ShiftRegisterKeys` object and call it **pad**.
```python
latest_event = Event()
last_event = Event()
pad = ShiftRegisterKeys(
clock=board.BUTTON_CLOCK,
data=board.BUTTON_OUT,
latch=board.BUTTON_LATCH,
key_count=8,
value_when_pressed=True,
interval=0.1,
max_events=1,
)
```
We do that by passing the `Clock`, `Latch`, and `Out` pins of the built-in shift register to the module. This is an SN74HC165 Parallel-Load Shift Register, which works by first "latching" the current input values of the buttons being pressed. Then the `Out` pin is read and the data is shifted each time a Clock pulse is sent. This way we can get any combination of the eight inputs from the shift register. This is all handled in the background which makes it much easier to use.
The `interval` of **0.1** , which is expressed in seconds, is important because it tells how CircuitPython how long to wait before reading the shift register. If it is read too frequently, then sometimes incorrect values are returned.
Next is the `check_buttons()` function. This function will read the event that is passed in to determine which buttons are being pressed and update the settings dictionary. By putting the checks in an else/if structure, it forces the code to only respond to one button press at a time.
```python
def check_buttons(event):
if event.key_number == BUTTON_RIGHT:
settings["direction"] = -1
elif event.key_number == BUTTON_LEFT:
settings["direction"] = 1
elif (event.key_number == BUTTON_UP) and settings["speed"] < 10:
settings["speed"] += 1
elif (event.key_number == BUTTON_DOWN) and settings["speed"] > 1:
settings["speed"] -= 1
elif (event.key_number == BUTTON_A) and settings["brightness"] < 0.5:
settings["brightness"] += 0.025
elif (event.key_number == BUTTON_B) and settings["brightness"] > 0.025:
settings["brightness"] -= 0.025
```
Finally let's take a look at the button code in the main loop, which handles the button presses.
```python
last_read = 0
while True:
for color in range(0, 360, speed):
pad.events.get_into(latest_event)
if latest_event.pressed and latest_event.key_number != last_event.key_number:
check_buttons(latest_event)
last_event = latest_event
latest_event = Event(
key_number=8
) # An imaginary key number that doesn't exist!
```
We start by grabbing the current value of the buttons and setting the time of the last read to 0. After that, we have a `for` loop to cycle through all of the different colors. I have omitted that code so that we can focus on the button code only.
In the last bit, it waits until the button is no longer pressed so that the button press events aren't continuously fired off, which would make changing settings very difficult.
## Featured Products
### Adafruit PyBadge for MakeCode Arcade, CircuitPython, or Arduino
[Adafruit PyBadge for MakeCode Arcade, CircuitPython, or Arduino](https://www.adafruit.com/product/4200)
What's the size of a credit card and can run CircuitPython, MakeCode Arcade or Arduino? That's right, its the **Adafruit PyBadge!** We wanted to see how much we could cram into a 3 3⁄8 × 2 1⁄8 inch rounded rectangle, to make an all-in-one dev board with...
Out of Stock
[Buy Now](https://www.adafruit.com/product/4200)
[Related Guides to the Product](https://learn.adafruit.com/products/4200/guides)
### Adafruit PyBadge LC - MakeCode Arcade, CircuitPython, or Arduino
[Adafruit PyBadge LC - MakeCode Arcade, CircuitPython, or Arduino](https://www.adafruit.com/product/3939)
What's the size of a credit card and can run CircuitPython, MakeCode Arcade or Arduino even when you're on a budget? That's right, it's the **Adafruit PyBadge LC!** We wanted to see how much we could cram into a 3 3⁄8 × 2 1⁄8 inch...
In Stock
[Buy Now](https://www.adafruit.com/product/3939)
[Related Guides to the Product](https://learn.adafruit.com/products/3939/guides)
### Lithium Ion Polymer Battery Ideal For Feathers - 3.7V 400mAh
[Lithium Ion Polymer Battery Ideal For Feathers - 3.7V 400mAh](https://www.adafruit.com/product/3898)
Lithium-ion polymer (also known as 'lipo' or 'lipoly') batteries are thin, light, and powerful. The output ranges from 4.2V when completely charged to 3.7V. This battery has a capacity of **400mAh** for a total of about 1.9 Wh. If you need a larger (or smaller!)...
In Stock
[Buy Now](https://www.adafruit.com/product/3898)
[Related Guides to the Product](https://learn.adafruit.com/products/3898/guides)
### Mini Oval Speaker - 8 Ohm 1 Watt
[Mini Oval Speaker - 8 Ohm 1 Watt](https://www.adafruit.com/product/3923)
Hear the good news! This wee speaker is a great addition to any audio project where you need 8 ohm impedance and 1W or less of power. We particularly like this speaker as it is small and comes with nice skinny wires with a connector on the end. It has a handy...
In Stock
[Buy Now](https://www.adafruit.com/product/3923)
[Related Guides to the Product](https://learn.adafruit.com/products/3923/guides)
### Adafruit Circuit Playground Lanyard
[Adafruit Circuit Playground Lanyard](https://www.adafruit.com/product/3987)
We've got our Circuit Playground friends on [lunchboxes](https://www.adafruit.com/product/3437), [posters](https://www.adafruit.com/?q=posters), [puzzle](https://www.adafruit.com/product/3817),
In Stock
[Buy Now](https://www.adafruit.com/product/3987)
[Related Guides to the Product](https://learn.adafruit.com/products/3987/guides)
### Double-Hook Lanyard in Adafruit Black
[Double-Hook Lanyard in Adafruit Black](https://www.adafruit.com/product/3982)
What did the lanyard say to the hat? _"You go on ahead, I'll hang around."_
Terribly good puns aside, we've got a **Double-Hook Lanyard** in classic Adafruit black.
This lanyard is a fantastic accessory for turning your
In Stock
[Buy Now](https://www.adafruit.com/product/3982)
[Related Guides to the Product](https://learn.adafruit.com/products/3982/guides)
### Mini SWD 0.05" Pitch Connector - 10 Pin SMT Box Header
[Mini SWD 0.05" Pitch Connector - 10 Pin SMT Box Header](https://www.adafruit.com/product/4048)
We've carrying a new 1.27mm pitch 2x5 **Mini SWD 0.05" Pitch Connector**. It's a tinier, bite-sized version of the [Box Header](https://www.adafruit.com/product/752) used on our
In Stock
[Buy Now](https://www.adafruit.com/product/4048)
[Related Guides to the Product](https://learn.adafruit.com/products/4048/guides)
### SWD 0.05" Pitch Connector - 10 Pin SMT Box Header
[SWD 0.05" Pitch Connector - 10 Pin SMT Box Header](https://www.adafruit.com/product/752)
This 1.27mm pitch, 2x5 male **SMT Box Header** is the same one used on our [SWD Cable Breakout Board](https://www.adafruit.com/product/2743). The header alone is great if you want to incorporate this piece of hardware with your own software.
In Stock
[Buy Now](https://www.adafruit.com/product/752)
[Related Guides to the Product](https://learn.adafruit.com/products/752/guides)
## Related Guides
- [Adafruit PyBadge and PyBadge LC](https://learn.adafruit.com/adafruit-pybadge.md)
- [Bounce - an accelerometer game in Arduino for PyGamer and PyBadge](https://learn.adafruit.com/bounce-an-accelerometer-game-in-arduino-for-pygamer-and-pybadge.md)
- [PyGamer NeoPixel Controller](https://learn.adafruit.com/pygamer-neopixel-controller.md)
- [Custom Color Palettes for MakeCode Arcade Games](https://learn.adafruit.com/custom-color-palettes-for-makecode-arcade-games.md)
- [PyBadge Case](https://learn.adafruit.com/pybadge-case.md)
- [PyBadger Event Badge](https://learn.adafruit.com/pybadger-event-badge.md)
- [CircuitPython Stage game library](https://learn.adafruit.com/circuitpython-stage-game-library.md)
- [Two Player Game System for PyGamer and RFM69HCW Radio Wing](https://learn.adafruit.com/two-player-game-system-for-pygamer-and-rfm69hcw-radio-wing.md)
- [Re-MakeCode the Classics: Py Hunter](https://learn.adafruit.com/re-makecode-the-classics-spy-hunter.md)
- [PyPaint Drawing Program In CircuitPython](https://learn.adafruit.com/pypaint.md)
- [JOY of Arcada — USB Game Pad for Adafruit PyGamer and PyBadge](https://learn.adafruit.com/joy-of-arcada-usb-game-pad-for-adafruit-pygamer-pybadge.md)
- [MakeCode Arcade: Sparky Invaders](https://learn.adafruit.com/makecode-arcade-sparky-invaders.md)
- [NES Emulator for Arcada](https://learn.adafruit.com/nes-emulator-for-arcada.md)
- [Creating Your First Tilemap Game with CircuitPython](https://learn.adafruit.com/creating-your-first-tilemap-game-with-circuitpython.md)
- [Making a Name Tag in MakeCode Arcade](https://learn.adafruit.com/making-a-name-tag-in-makecode-arcade.md)