MintyPiPico tiny video game - PCB version

MintyPiPico is a mini handheld gaming console

MintyPiPico is a super tiny handheld clam shell device inspired by the Minty Pi Altoids tin video game, but it uses the RP2040 Zero and an even smaller Altoids Smalls tin. It has an almost instant power-on, and can play NES and Gameboy games. It's based on the PicoPad schematic and PicoLibSDK library by Miroslav Nemecek. Now I've made it much easier to build with a pre-built PC board.

First look at a completed MintyPiPico using the pre-built PC Board:

The previous version was hand-built; this version uses a custom designed PC board containing essentially everything except the components on an RP2040 Zero board.

Here's what the pre-built boards look like, top and bottom.

Here's an exploded view of an early build before assembly into the case.

It was a significant challenge to get everything to fit inside the case.

Supplies

Shown here are the main components you'll need to build the MintyPiPico.

Assembly instructions

Standard disclaimer: Don't build this yourself! If you really want to build one, please read the entire instructions before ordering the board, and convince yourself that you can handle it. It is definitely not a beginner project, more like an intermediate-advanced project. Challenging is a good word to describe it.

The board set consists of a display board and a main board.

3D printing

3D print the three parts needed: the LCD bezel, base, and locking ring using PLA filament on any cheap 3D printer with 220 deg C nozzle temperature. A heated bed is not needed, just roll-on glue on the base. The LCD bezel and locking ring should be printed with 100% infill, and the base can be printed with 15% infill. No fancy settings are required.

The locking ring is provided in various sizes in case you have difficulty getting everything squeezed into the case. Try the standard size first, then different variations if you have difficulty.

Display board assembly

Display board assembly is simple, only two parts need to be attached to it.

1. Lightly tin the 12 lands of the flat flex cable connector CONN1 and the LCD connector LCD1 on the display board. Applying some flux before tinning makes it much easier.

2. Align the flat flex connector CONN1 with the outline on the board, and manually solder each pin to the board. Confirm that each pin is secure by applying light pressure sideways on each pin with a sharp tool. Inspect them using reading glasses, a loupe, or a microscope for open connections or shorts between pins. Bad connections here will result in no display.

The solder connections should look something like this.

3. Use a toothpick to apply a tiny bit of super glue on the pin side of the connector to the board. Be extra careful not to get any glue on the sides of the connector or the black clamp.

4. Now align the LCD flex cable as shown over the lands labelled LCD1, beinging sure that pin 1 on the cable is aligned with pin 1 on the board, and the cable is square with the board.

5. Secure the LCD flex connector to the board as shown with Kapton or electrical tape so it doesn't move while soldering.

6. Gently press a small tipped soldering iron at 350 deg C on top of each pin for 2 to 3 seconds only. Solder from the pads on the board will flow through the tiny vias on the LCD flex cable contacts and secure it to the board.

The solder connections should look something like this.

7. Verify with an ohmmeter in continuity beeper (diode) mode that each pin of the LCD connector LCD1 is connected to each pin of the flat flex connector CONN1. Also check for shorts between adjacent pins. Note that pins 1, 5, 6, and 12 are connected together as GND, so it should be showing a short between those pins.

8. Place a piece of double-sided scotch tape on the back of the display board (the side without connectors).

9. Fold the LCD flex cable snugly around the edge of the board and stick the back of the LCD display to the back of the board with the double-sided scotch tape.

10. Place some Kapton tape over the LCD flex cable as shown to help secure it in place.

11. Remove the protective film from the LCD display, and fit it carefully into the 3D printed LCD display frame. CONN1 should face the cutout in the frame for the flat flexible cable. Trim anything necessary to ensure that the LCD display sits flush against the frame.

12. Using a toothpick, put a few tiny drops of superglue on the back edges of the display where it meets the frame to secure it to the frame. Be careful to not get glue on the front of the LCD display.

We'll finish assembling the display into the lid after checkout of the display with the main board.

SD card preparation

Prepare the micro SD card as follows:

• Get a new or formatted 4GB or larger micro SD card of any type or speed.
• Go to the download tool at https://download-directory.github.io/
• Enter this address https://github.com/Panda381/PicoLibSDK/tree/main/PicoPad and press Enter.
• The contents for the micro SD card will be downloaded to your computer.
• Copy the downloaded contents to the micro SD card. Your SD card preparation is now complete!

Programming the RP2040 Zero board

Program the RP2040 Zero board as follows. These instructions apply for Linux, Windows, and Mac systems.

• Go to https://circuitpython.org/board/pajenicko_picopad/.
• Download the latest version of the CircuitPython.UF2 file for RP2040
• With the RP2040 Zero board unplugged, hold down the Boot button while plugging the board into the USB cable on your computer, then release the Boot button. The board will now be in bootloader mode.
• A window will pop up on your computer showing a folder on the RP2040 called RPI-PR2. Drag and drop or copy the CircuitPython UF2 file there.
• After the file has been copied over, the RP2040 will reboot, the RPI-PR2 window closes, and a CIRCUITPY folder on the RP2040 will open, which you can ignore. The PicoLibSDK library, the heart of the PicoPad software, is now loaded into flash memory on the RP2040 Zero board.
• Now go to https://github.com/Pajenicko/Picopad/blob/main/PicoLibSDK/binaries/UF2/GAME/MULTISET.UF2 and click the download button on the right side of the screen to save the UF2 file to your computer. This UF2 file contains the full 16 game set for PicoPad. It also contains the bootloader program, which you'll need to load any other game.

• Unplug the RP2040 Zero board, then hold the Boot button down again while plugging the board in, and release the Boot button.
• Again, the RPI-PR2 folder opens. Drag and drop or copy the MULTISET.UF2 file into that folder. After it copies, the RP2040 reboots, the window closes, and again the CIRCUITPY folder opens, which you can close.
• Loading the MULTISET program actually loads two things into the RP2040 flash memory: the 16 game program and the bootloader, which is required to be able to load any programs from the micro SD card. Now whenever the SD card Enable switch is set to Enable (left position), it will show a navigation menu on the screen on power up. Navigating to any program on the SD card and pressing the "A" button will load that program. Actually, every program you load from the SD card has a copy of the bootloader in it, as it will need it to load the next program you want to run.
• After loading a program from the SD card, remember to return the SD card enable switch to Disable (right position), so that the program runs on next power up, and not the bootloader menu.

This completes programming of the RP2040 Zero board. You will not need the USB-C connector or Boot button again, because all UF2 program files will be loaded from the micro SD card using the bootloader program.

Main board assembly

Steps 1 through 3 are not needed when you build it, as these modifications are completed before the boards are shipped out. They are only included here for documentation purposes.

1. Add a 2.2kOhm pull-down resistor to the 5V_SW line.

2. Change capacitor C3 from 1uF 16V 0603 size to 10uF 6.3V 0603 size.

3. Add the missing low battery sensor chip U5.

4. Use four M2x4mm self-tapping screws to temporarily mount the main board into the base, so that you can check positions of the holes to be cut in the next step. You will remove it after all of the holes are cut properly.

5. Cut holes for the USB-C port, SD card enable switch, and micro SD card slot in the front of the tin as shown in the template below. Yes, it will be ugly. The best way I've found is to use a hand pin vise to drill holes along the center of each opening, clip away the material between holes, and then use a small set of hand files to enlarge and shape the opening. It is possible to use a Dremel tool, but only after drilling a small amount with a hand drill to center the Dremel drill bit. Otherwise, the drill bit will move wildly over the surface.

Confirm that when the base is centered and pressed all the way into the tin, you can plug in a USB-C cable, access and move the SD card Enable switch, and insert and remove the micro SD card. The switch is recessed quite a bit, so you'll need a paper clip to move it. The SD card slot is spring loaded: press the card in with a paper clip to insert, press again to release. The card goes in upside down.

I'm looking for a way to get these tins laser cut for a reasonable price, which will definitely save time and make the project more fun.

Here are the sizes and locations of the center of each hole to be cut, measured from the center of the top rim of the tin.

NOTE: Steps 6 through 8 are needed to reduce thickness of the board by 2mm so that everything can fit into the case. These steps can be delayed until you confirm that everything works OK. It is just a bit more difficult to do these steps once you’ve got all of the wires connected. If you’re confident you’ve programmed the RP2040 Zero board properly, then it’s best to do steps 6 through 8 now.

6. Remove the LED from the RP2040 Zero board. The LED will stay ON once it's programmed in the previous step, and it draws 60mA of current, adding to battery drain, so it needs to go. It can just be cut off with wire cutters, with little risk of board damage. You could also use a hot air rework machine set to 370 deg C at 50% air flow (or soldering iron) and tweezers.

7. Remove the Boot and Reset buttons from the RP2040 Zero board. This is necessary to reduce the height by 2mm so that the board fits all the way down into the tin base. To remove the buttons, you can use a hot air rework machine set to 370 deg C at 50% air flow and tweezers. It's also possible to use a soldering iron and solder wick, but be sure to preserve the pads on the Boot and Reset buttons, as we will solder wires to them later. Putting some flux on the leads first makes removal much easier. Clean it with isopropyl alcohol afterwards.

8. Use a hot air rework machine set to 370 deg C at 50% air flow to remove the USB-C port from the RP2040 Zero board. This is also required for that extra 2mm height reduction. Holding the port with locking forceps at the entry end works best. The port actually comes off quite easily this way. If you don't have a hot air machine, I suggest cutting the four mounting pins with wire cutters, then desolder the fine pitch data and power pins. Use flux on the pins to help desolder them easier. It actually doesn't matter if you damage or lift the fine pads, as they are not used anymore. Just don't leave any shorts between pads. And be careful not to damage any small components that are near the USB port contacts.

9. Cut and strip 25 2" lengths of 30GA wire wrap wire. Seven wires need 1/16" stripped on one end and 1/8" on the other end for the next two steps, and the rest need 1/8" stripped on each end.

10. Solder 2" long 30GA wires to the boot and reset pads shown using the 1/16" stripped end. Then apply solder mask to secure the wires, and cure with a UV flashlight for at least 5 minutes. The solder mask acts as a strain relief. Connect to either inside switch pad as shown; the outside pads nearer the board edge are connected to ground.

11. Solder 2" long 30GA wires to the five mini pads GP17 through GP21 indicated below using the 1/16" stripped end, but first trim the stripped portion to be no longer than the mini pad length. Use flux and solder to tin the mini pads first, and tin the ends of the wires going to the mini pads. Be careful not to damage or short to the capacitor near mini pad GP21. After soldering, clean the flux off with a cotton swab and isopropyl alcohol or acetone (plain nail polish remover). Then apply the solder mask to secure the wires, and cure with a UV flashlight.

Sorry, these pads had to be used to avoid changing the software to assign them to outside pads.

12. Solder 13 2" long 30GA wires to GPIO pins 2 through 13, and 15 on the RP2040-Zero board. Trim excess wire sticking out of the board to avoid shorts.

13. Solder all of these wires to the corresponding holes in the main board, from the bottom. Trim excess wires coming through the top so they don't interfere with the rubber keypad membrane.

Since the text for the GPIO holes is too small on the board, use the following guide to locate each hole. And sorry for putting the holes so close together. Oops!

14. Inspect all solder connections to verify there are no shorts between pads. It's very easy for the small 30GA pads all in a row to short out with a solder blob, because they were placed too close together. Ask me how I know. Inspect with reading glasses, a loupe, or a microscope. A short between holes looks as innocent as this photo, and can cause a blank screen until the short is removed.

15. Refer to the Wiring Diagram below for the following wires connecting to the main board. Use 24GA wire or larger for 5V_SW, GND, and 3V3.

16. Connect 5V_SW on the main board, through a 1N4001 or 1N5817 diode, to the RP2040 Zero 5V pin. The cathode (stripe mark) connects to the RP2040 Zero board. Cover the diode with heat shrink tubing to avoid shorts. The diode and heat shrink will be included with the board. This diode is needed due to a design oversight.

17. Connect GND on main board to GND on RP2040 Zero board.

18. Connect 3V3 on main board to 3V3 on RP2040-Zero board. It should now look something like this, with the RP2040 Zero board positioned at the USB-C connector end of the main board, and the diode tucked between the boards.

19. Now connect the speaker to SP+ and SP- on main board. Leave enough wire to position the speaker at the end of the board next to the SD card slot. You can solder wires to the speaker as shown. Polarity doesn't matter.

20. Connect the battery (+) wire (red) to BT+ on main board.

21. Confirm with an ohmmeter that BT+ is not shorted to the frame of the power button, which is grounded. They're very close together and can easily short together when soldering, which would short out the battery once BT- is connected. This wouldn't damage the battery, as it has built-in short circuit protection. It just...wouldn't work.

22. After confirming there is no short between BT+ and the power button frame, solder the battery (-) (black) to the GND hole (not the BT- hole) on the main board. We use the GND hole because the BT- hole is too close to the flat flex cable and will interfere. Oops.

23. Make sure the black flip lever on CONN1 on the main board is lifted, and the insert the flat flexible cable into the connector. The contacts should both be facing DOWN towards the board. Ensure that it's centered and pushed all the way in, then flip the lever down. The cable should be square with the connector, and not pull out easily. NOTE: FFCs have a limited number of insertions before they wear out, which can cause a blank display if it's removed too much.

24. On the display board, pull out the black retaining bar on CONN1, insert the FFC the same way, with contacts down. Then push the black retainer bar in to lock the cable into the connector. Check for squareness and a snug fit.

25. Insert the micro SD card as shown, and move the switch next to it towards the SD card slot (SD card disabled), so that the unit will boot up to the default Multiset program of games, and not the SD card bootloader menu.

26. Now, the moment you've been waiting for! Press the power button, and the screen should light up and display the multi games menu. You can lay the rubber membranes over the buttons and navigate to a game, and Press "A" and try it out.

If the screen doesn't light up, it's time to check and recheck all connections.

• Look for solder bridges between wire connections.
• Make sure the flex cable is properly plugged in both ends with contacts facing down towards the boards..
• Does the backlight turn on? You should see it dimly even if there is no image on the screen.
• Check the voltages on the LCD connector.
• Check the voltage on the battery, which should be between 2.9V and 4.2V. If it's below 2.9V, you'll need to charge it.
• Check if the 5V_SW voltage to GND turns on and off with each press of the power button.
• Verify that whenever 5V_SW is ON, there should be 3.3V on the 3V3 wire, which comes from the RP2040 Zero board.

And if you still can't figure it out, by all means contact me. The boards are all tested before shipment. I can't guarantee success, but I can help.

Installing everything into the case

Now the fun part: cramming everything into that tiny tin.

1. Remove the lid of the tin by carefully bending the bottom tangs that hold it on. The tangs can actually be removed, or flattened, as they are not needed.

2. The set of DS Lite replacement buttons comes with more buttons than you need. We'll only use the A/B/X/Y buttons, the D-pad, and one of the small round buttons for power ON/OFF.

Because 3D prints and button sizes will vary, you need to test fit the A/B/X/Y buttons into the 3D printed base. If they don't move freely, use a tapered reamer, Xacto knife, or small round file as shown to widen each hole until the buttons move freely. Take off very little each time, just a half turn on the inside and outside is usually enough. Depending on how clean your 3D print is, you may also need to clean off some nubs on the back side where the buttons sit.

Also, some buttons have tiny injection molding nubs at the edge that you’ll need to trim off to allow the button to move freely. Just be sure not to cut the small square alignment nub on each button A/B/X/Y.

Also check the D-pad and power button opening to make sure they move freely, and trim the openings as needed.

3. Place the A/B/X/Y buttons, D-Pad button, and Power button into their holes as shown, making sure each button is facing the right direction.

4. The rubber membrane set is shown here. Cut the small rectangular rubber pad in half; we'll only use half of it.

Trim a small amount off each large rubber button pad as shown below, so they don't touch each other when placed into the case. Place them into the case as shown. The black rubber contact should be showing. Also place the small square pad onto the reset button back as shown.

5. If there are any fingerprints on the button pads of the main board, clean them with a cotton swab and isopropyl alcohol.

6. Remove the SD card, and disconnect the flat flex cable from the main board. Place the wired up and tested board into the base, being careful not to move any of the the rubber pads. Secure with four M2x4mm self-tapping (or machine) screws, using a PH1 Philips bit and medium hand torque.

NOTE: If you need to remove the screws, when re-installing them be sure to turn the screw counter-clockwise first until you feel it click into the existing cut threads, and then tighten. You can remove and install them many times without damaging the cut threads.

7. Before you can insert the flat flex cable into CONN1 on the main board, you must make sure that the following wires are pressed flat against the board and routed out of the way of the flat flex cable:

• The 3V3 wire
• The 5V_SW wire (going through the diode to 5V on the RP2040-Zero
• The small GP4 wire.

8. With the contacts of the flat flex cable pointing down towards the main board, insert the cable through the rectangular hole in the base, and all the way into CONN1 on the main board, then flip the black lever down to secure it. Make sure it's square and all the way in, and does not pull out easily. You can check it by temporarily connecting the LCD display board and powering it up.

Unlock the display flat flex connector by pulling the black retainer clip away from the connector. Then push the flex connector into the display connector. NOTE: You’ll need to apply a firm force to the flat flex cable when pushing it into the connector on the display board, unlike the main board connector which has zero insertion force. Push the black retainer towards the connector to lock it.

9. Check the operation of the buttons and D-pad to ensure it's smooth and the membranes are still in place.

You can test the action of each button and the D-pad by using a test program for this purpose from the SD card bootloader menu. Access it as follows:

• Slide the SD card enable switch left (away from the SD card slot) to enable the SD card.
• Power off then power on.
• The SD card menu will appear. Use the D-pad to move down to the [TEST] folder, and press A.
• Move down to the KEYPAD entry and press A. The keypad test program loads. Press each button several times to confirm that they're working reliably and don't stick. Each button will light up on the screen when it's pressed. If a button is not working reliably, you may need to remove the board and re-seat the membrane for those buttons.
• When done testing buttons, hold the Y button for 2 seconds to exit the test program.
• Now you'll need to load back whatever game you want to run, otherwise the test program will load on power up. Use the D-pad to move up to the [..] symbol (previous folder), and Press A.
• Use the D-pad to move to the [GAME] folder, and press A.
• Now move down to MULTISET and press A. Or maybe just load PACMAN. You can load other games in a similar manner.
• After the program is loaded, be sure to move the SD enable switch back to the right (toward the SD card slot) to disable the SD card, so the loaded program will run next time it's powered on.

10. Now bend the flat flex cable up towards the top of the base.

11. Cover the bottom of the tin with Kapton or electrical tape as shown to prevent shorts. Kapton is better because it's thinner, and space is at a premium.

12. Now we need to make some replacement hinges for the lid, because the lid is 5mm away from being able to snap closed as it originally did.

Take two pieces of Nickel strip 8mm x 0.1mm, and 18mm long. Bend it like this, and tin opposite ends as shown.

Feed the strips through the slots in the lid and the top of the hole on the back of the bottom tin. Hold the tinned portions together with forceps as shown, and solder the ends together. Repeat on the other side.

It should look like this when you're done. Not pretty, but that's what trying to cram a video game into a tiny tin does.

13. Put some Kapton tape on the back of the speaker so that the wires don't short to the board when it's all assembled. The speaker must fit between the main board and the battery. Position the speaker between the screws, not over them. It can be mounted either way up. Tack it to the board with a little bit of super glue so it doesn't move when inserting everything into the tin base. The speaker will radiate through the board and battery, so it doesn't need any holes in the tin.

14. Arrange the battery, speaker, and RP2040-Zero board as shown. The speaker is under the battery on the right hand side.

15. Holding everything as much as possible inside the confines of the 3D printed base, insert the base into the bottom of the tin. The top of the base should be just below the rim of the tin when pressed down. If it doesn't press down far enough, remove it and make sure the battery, speaker, and RP2040 Zero board are not interfering with each other. Also check that you have not pinched any of the wires between the 3D printed base and the bottom of the tin.

If you have difficulty getting it all to fit in the tin, you may try something like this using Kapton tape to hold the RP2040 Zero board down, and then another piece to hold the battery down. This way, it keeps everything well within the 3D printed base while you insert it into the tin. Note that the battery can extend outside the 3D printed base corner, since there is extra room inside the tin.

16. Now work the thin 3D printed locking ring between the bottom lip of the tin base and the top of the 3D printed base. Use a pair of flat-nosed pliers to force it under the rim, locking in the 3D printed base. If the battery, RP2040-Zero board, and speaker are properly placed, it should all fit.

The standard locking ring is 1.5mm wide and 0.6mm thick, but you may need to use the 0.5mm or 0.4mm thick version if the fit is too tight. But before going to a thinner version, first check that you have not caught any wires between the 3D printed base and the bottom of the tin. There are also 2.5mm wide versions of each thickness, in case you find the 1.5mm wide version too hard to wrangle, or it doesn’t hold well enough.

Work your way around. The locking ring is shorter than what is shown. And here's the locking ring fully installed.

17. Insert the micro SD card, and move the switch next to it towards the SD card (SD card disabled), so that the unit will boot up to the default Multiset program of games, and not the SD card bootloader menu.

18. Apply three layers of 3M Very High Bond VHB tape in two rows to the back of the display board as shown here. This is needed to hold the display securely in the lid. The red backing must be removed between layers. Multiple layers are needed to match the 2mm height flex connector height. You can also use double-sided sticky foam pads.

Unlock the display flat flex connector by pulling the black retainer clip away from the connector. Then push the flex connector into the display connector. NOTE: You’ll need to apply a firm force to the flat flex cable when pushing it into the connector on the display board, unlike the main board connector which has zero insertion force. Push the black retainer towards the connector to lock it. Confirm that everything still works OK. Then remove the backing from the top layer of tape.

19. Now press the display and bezel into the lid, and it should stick there. Removing VHB tape is not easy, but you shouldn't need to remove it.

And...it's done! Enjoy showing it off to your friends and family.

Theory of operation

Here I describe how each part of the circuit operates.

Charging circuit

The charging circuit is basically the same as the original PicoPad.

The USB-C connector has 5.1kOhm resistors to tell the charger that this is a simple 5V device drawing no more than 500mA. R13 limits the current. U1 manages the battery charging. No additional protection chips are necessary because the battery has built-in battery protection, preventing short-circuits, over-charging, and over-discharging. LEDs indicate when the battery is charging (red), or fully charged (green). Resistor R8 sets the charge current to 1C, and can be modified if you use a larger battery. Pin 5 of U1 outputs the charging voltage to the battery.

5V boost regulator and low battery indicator

The original PicoPad uses a Raspberry Pi Pico board, which has it's own regulator. The MintyPiPico uses the same boost regulator U3 to raise the battery voltage from the 2.9V to 4.2 V range, up to the 5V required by the RP2040 Zero board and the audio amplifier. Actually, the RP2040 Zero only needs 3.3V, and has it's own Low Dropout (LDO) regulator to generate it's 3.3V. So the RP2040 Zero board's 5V input really only needs 3.62V minimum. So the voltage drop on the diode in the 5V_SW line doesn't matter.

The output of the RP2040 Zero LDO regulator is fed back to the main board on the 3V3 wire to power the SD card and LCD display.

I've added a low battery sensor IC, U5. It monitors the battery voltage during operation when 5V_SW is active. When the battery falls below 2.9V it will light the Low battery LED (red). This gives the user one or two minutes warning before the MintyPiPico shuts off from the over-discharge protection built into the battery. It's handy only from the standpoint of not wondering why the screen went black suddenly when the battery shuts down.

Power switch circuit

Rather than have a slide switch to turn the unit on and off, I used a common push ON/push OFF circuit shown here. The only thing I forgot to add was a 2.2kOhm pull-down on the 5V_SW output, and a diode to the RP2040 Zero board. Without these, the MintyPiPico can turn on, but never turn off! Somehow when I breadboarded this circuit, it worked with out these components. But when the boards arrived, it took a bit of debug to discover that capacitors on the RP2040 Zero 5V input were keeping the circuit turned on.

The output of the 5V boost regulator is always active when the battery has a charge on it. Current draw for the boost regulator in this state is only a few microamps, so its not an issue. A full battery will hold a charge for weeks when the MintyPiPico is turned off.

Here's how the circuit works:

Capacitor C1 is initially charged up to 5V through resistors R1 and R2 by the ever-present 5V input. Pressing the power button passes this 5V to the gate of Q2, turning on Q2. This turns on Q1, which provides 5V to the 5V_SW output, powering up the MintyPiPico. But a short time after Q2 turns on, C1 gets discharged by Q2 through R2. So the next time the power button is pressed, the near zero volts on C1 is passed to the gate of Q2, and Q2 is forced off. This turns off Q1, powering down the unit.

Now that Q2 is off, C1 is free to charge up again through R1 and R2, and ready for the next button press to turn 5V_SW on again. It's a clever minimum parts count circuit.

Backlight delay and LCD interface circuit

The 3.3V from the RP2040 Zero board powers the LCD backlight, the LCD electronics, and the backlight delay circuit. It is active whenever 5V_SW is active, when the MintyPiPico is ON.

R6 drops the backlight voltage to the 3V maximum recommended, as it can't handle the full 3.3V. It feeds the Anode (+) of the backlight LEDs, LEDA. The cathode LEDK of the backlight (-) was connected to ground in the PicoPad, so that the backlight was on whenever the PicoPad is on. During power-up, before the RP2040 is initialized and the LCD electronics are fed a reset command, random stuff appears on the screen.

To eliminate this, I added the backlight delay circuit around Q3. This circuit pulls the cathode LEDK of the backlight to ground within two seconds, which results in an elegant soft turn-on of the LCD display.

The value of C3 will be changed to 10uF on each board to give the correct delay, as my breadboard circuit did not accurately predict the correct value.

There are five control lines from the RP2040 Zero that send data to the LCD display. It should be noted that the LCD vendor signal names SCL and SDA are in fact incorrect naming, as SCL and SDA are only used for the I2C (Inter-Integrated Circuit) protocol. This display uses the SPI (Serial Peripheral Interface) protocol, so SCK and MOSI (Master Out Slave In) are the correct names. The PicoPad schematic uses the correct names given in the right column of the table.

SD card interface

The micro SD card interface has four SPI lines coming from the RP2040 Zero. Power is supplied by the 3.3V supply.

The SD_CS chip select line goes through the SD Enable switch. When the switch is open, no SD card access is possible. When the switch is closed, SD_CS gets passed to the SD card and access is possible.

On power up, one of two things will happen: The game or program presently loaded in the RP2040 flash will run, or the bootloader will come up with a menu of the SD card contents. The SD Enable switch determines which happens. This simple feature allows you to keep the micro SD card in the slot and not have to remove it after you load a new game from the SD card.

To load a new game from the SD card, move the SD Enable switch away from the SD card slot (left), and cycle power. The bootloader menu comes up, and you simply navigate to the game or program you want to load and press "A". The program loads and opens. Now move the SD Enable switch to the right, so that the next time you power up, the game loaded in flash will run.

Audio amp

The original PicoPad used a single transistor driving a piezo speaker from 5V, which worked well for most video games.

In early testing, I found that the Pacman game would leave the RP2040 audio output GPIO15 at 1.4V, which resulted in 1 watt being dissipated by the 8 Ohm speaker. This not only burns precious battery power, it might eventually burn out the speaker. The PicoPad uses a piezo speaker, so this voltage won't matter because of their high resistance. Power cycling fixed the issue, but I wanted a fool proof method. So I added a simple class B push-pull amplifier that is capacitively coupled to guarantee 0 volts across the speaker when nothing is playing.

It also turns out this works well with the new MP3 player that has been added to the PicoLibSDK. The sound quality is quite good, for a cell phone speaker radiating through the main circuit board.

Buttons, buttons, and more buttons

MintyPiPico uses the exact same button scheme as the PicoPad. Not much to see here.

RP2040 Zero components

The RP2040 Zero board schematics are shown below.

Components that are used on the MintyPiPico are:

• The RP2040 processor
• An RT9013-33 3.3V 500mA LDO regulator that provides power to the RP2040, and also the main board LCD and micro SD card.
• A 16Mbit W25Q16JVUXIQ flash memory to store the game or program
• A 12MHz crystal used by the RP2040

The following components are not used:

• Boot and Reset buttons, removed after it's been programmed
• An RGB LED, removed, not needed and draws current
• The USB-C connector, removed after it's been programmed

Design challenges

Here are some of the challenges in getting this project designed, built, and working.

I originally designed an all-in-one board to eliminate the RP2040 Zero board, but this ended up being too expensive. A more detailed explanation is at the end of this section.

Since the tin will not close the full way as designed, the lid sits higher than normal. So the metal hinges have to be made out of the 8mm x 0.1mm nickel strip that is typically used to connect Li-ion battery cells together.

There was no room for the speaker, because it was so cramped in there. In desperation, I temporarily sandwiched it between the board and the battery. Turns out, that was an unintentionally brilliant move! The speaker vibrates through the board and bottom of the case, and has lots of volume. Amazing!

I used Very High Bond 3M VHB tape to attach the display inside the lid, just like they did on Minty Pi. Three layers were needed to match the height of the FFC connector. It is solid!

To get the base to stay in the tin, on the first prototype I used metal epoxy. Not very reversible. On this build, I devised a 0.6mm thick locking ring to hold the 3D-printed base secure in the tin base, and it seems to have worked well. There are 0.5mm and 0.4mm thick versions available if things are too tight on yours.

In order to get everything to fit, I had to modify the RP2040 Zero board by removing the USB-C port, push buttons, and LED. This shaved 2mm off it's height, which was just enough. The LED is removed because it would always be ON due to the software, and it draws 60mA! The MintyPiPico itself only draws about 200mA. Once the RP2040 is programmed with CircuitPython and the initial game program, the USB port is no longer needed, as everything gets loaded from the micro SD card via the bootloader.

The Reset and Boot buttons are not needed after programming because they're wired to the main board, and can be actuated through the front panel with a paper clip. Actually, once you remove the USB-C connector, the Boot button is not needed because it works in conjunction with the USB-C connector on the RP2040 Zero board, which we removed. Oops! Not well thought out. Reset is actually rarely needed, as a simple power cycle will fix anything.

The SD card switch determines if power-up will run the currently loaded game/program, or bring up the SD card navigation menu. This works great, so you don't need to pop out the card after loading a program from it. To switch it, use a paper clip. Moving towards the SD card slot disables the SD card. Will reverse that on the next version.

So, a whole bunch of the through-holes were not placed...let's say ideally. They will be moved accordingly on the next version.

• The BT(-) battery hole is clearly in the way of the flex cable, and so the battery negative wire is connected to the GND hole instead.
• The BT(+) battery hole is dangerously close to the power button frame, which is grounded and can easily short out when soldering to it. Not good. So the instructions say to connect this before BT(-), then verify with an ohmmeter that BT(+) is not shorted to ground, then solder BT(-). The battery has short-circuit protection built in, so no fire hazard exists. Will move that on the next revision.
• There are a bunch of GPIO holes spaced 1mm apart, which was unavoidable due to how tight the layout was. But this commonly results in solder blob shorts between holes, and nothing works. A microscope helps to find these. The next version will stagger these so there is more space between them.
• The power, speaker, and battery holes are clearly a bit too large, but they work. They looked so small on the screen. The GPIO holes are just right, and the 30GA wire wrap wires fit well.
• The 5V_SW and 3V3 holes are also in the way of the flex cable, and will be moved on the next revision. Also GPIO4 needs to move from that area.

The diode between boards is needed due to a design oversight. Without it, the board will turn on, but never turn off! The diode should be covered with heat shrink tubing, both of which are included with the board.

I also had to add a 2.2kOhm pull-down resistor on the 5V_SW output going to the Pi Pico, for the same reason. This will be added to each board.

The backlight delay circuit (described below) did not have the correct delay, so on each board I'll change C3 to from 1uF to 10uF.

Of course, the diode, 2.2kOhm pull-down, and C3 value change will occur on the next revision.

On the first spin of the display board, I put the flat flex connector on the wrong side of the board. D'oh! Two spins later I got it right. Thankfully, that board was cheap.

All holes need to have identifying text on both sides of the board for easier assembly.

Text size of 0.5mm for the GPIO holes is below the minimum 1mm recommended, and is very hard to read. The next version will use 1mm text height. It looked sobig on the screen!

The display bezel could be moved 2mm further into the lid by soldering the flex cable to the display board. It would require a redesigned bezel and cutouts in the base for the corners of the LCD display. An there is still 3mm more needed for the lid to snap closed as originally designed.

Overall, I was pleasantly pleased that this first version of the PC board worked so well!

Speaking of ports, cutting out the holes for the ports is always time consuming. Be sure you're up for this before attempting this project. I'm looking for a way to punch out a bunch of cases I can sell so you don't need to go the painful and sloppy route of drilling and filing.

During the build, they ran out of the sense ICs U5 for the low battery LED, which comes on when the battery gets to 2.9V. So I'll manually solder these onto each board.

I've made provision for putting standard SMD 4.5mm square dome buttons on the board, for those who like the more solid clicky feel. But it's intended for just membrane buttons like the DS Lite happily used.

I designed an all-in-one board that includes parts that are on the RP2040 Zero board, but that required a 4-layer board instead of this much cheaper 2-layer board. It was twice as expensive, and not knowing the demand for these, I decided on this cheaper 2-layer approach. Perhaps if these sell well enough to recoup my costs, I'll make an all-in-one version similar to what is pictured below. This will allow the for a larger battery, and for the lid to close further. This render also shows the dome switch buttons installed.

I'm constantly cogitating on a way to make a small 4-layer daughter card that solders flush to the main board, to eliminate all those wires, and maybe, just maybe, be able to get the lid to close. Stay tuned.

Other fun stuff you can do with the MintyPiPico

There is much more to the PicoPad and MintyPiPico than just video games. The RP2040 is a very powerful processor, and Miroslav Nemecek has included 56 sample programs and games in the SD card image. You load them from the SD card bootloader menu, and exit by pressing "Y".

You can review all of the programs on his website here.

These include:

• PicoPad configuration: not all of these are compatible with MintyPiPico
• SD card bootloader: already loaded with the first game of program
• Frequency generator: works by selecting GPIO15 - very high quality tones and various waveforms available
• Frequency meter: needs external connection, but very accurate
• RC meter: needs external connection and components, measure resistor and capacitor values
• Calculator emulator
• Pictor game
• Game Boy emulator: for the ROMs you own
• NES emulator: for the ROMs you own
• See http://www.breatharian.eu/hw/picolibsdk/index_en.html#picopad for details on how to compile the NES and Gameboy ROMs you own into UF2 files that you can load.
• Measure timing of RP2040 floating point functions
• MP3 player: works great! Outputs mono audio on GPIO15 to the internal speaker. There is also an option for stereo output using a few more components - add a headphone jack!
• Some of the programs are set up to use a USB mouse and keyboard, but the D-pad and buttons provide some limited functionality.
• [BOOK] contains a story book
• [COLBOOK] contains a coloring book.
• [DEMO] has lots of cool demo programs to show off the graphics and computational ability of the Pi Pico.
• [MEASURE] allows you to measure Pi Pico performance and other things that may not be supported by this hardware.
• [PAINTER] contains a paint program.
• [PROG] is a Mandelbrot program.
• [SLIDE] is a slideshow demonstrating the video quality.
• [VIDEO] contains some sample videos. Although running at only 10 frames/second, these videos are actually quite good! Check them out. He provides detailed instructions to encode your video on his website linked above. The process is not easy, but possible.

Have fun exploring! There's lots of good stuff there.