ragediablos/Arduino-PipBoy3000
Use Git or checkout with SVN using the web URL.
Work fast with our official CLI. Learn more.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching Xcode
If nothing happens, download Xcode and try again.
Launching Visual Studio Code
Your codespace will open once ready.
There was a problem preparing your codespace, please try again.
Latest commit
Git stats
Files
Failed to load latest commit information.
README.md
Code/Ideas for my Arduino projects! DIY Pipboy 3000 setup with TFT screen and analog buttons for control alpha v .1 NOTE readme.md is still being updated
INSTALLATION**********
1.Files Included with pipbot open source project.
- 3D Print Files for Frame for the Pipboy3000
- 3D Print files for fallout4 edition will be added a later time.
- thanks to YTECH for sharing this project the mproject described on this page is licensed under the Creative commons — Attribution — ShareAlike license.
- look at wiring diagram in the img folder for hook-up for 4d systems screen.
- use 4D systems IDE to install files to screen.
- the pipboy.ino file is the code for the buttons to interact with the screen plus features.
- 3D printer source files from dragonator.
- 4D Systems 4.3 inch touch display.
- 8 gig micro SD card.
- Adafruit PowerBoost 500 charger/booster.
- Lipo 2500mAh 3.7v battery.
- USB breakout board.
- 10 Position rotary switch.
- 3 orange LED’s.
- 1 red LED.
- 1-10k resistor.
- 2-220ohm resistors.
- raspberry pi or arduino for addtional add-ons
How to Make a PIP-Boy (Prototype)
Introduction: How to Make a PIP-Boy (Prototype)
So what exactly is a PIP-Boy, you ask? For those unfamiliar, a PIP-Boy is a device used by the protagonist in the popular Fallout series of video games for navigation, radiation detection, data storage/playback, and inventory management. Being a major fan of the franchise, I decided I wanted to make my own version, but no mere prop, I wanted a functional device that I could really use. This version is very much just a working prototype and a platform for future development. My ultimate goal is to build a fully functioning PIP-Boy 3000 from scratch, so this is my platform upon which I can build up to that level.
Hey, I’m a big fan of Fallout too! But PIP-Boys don’t look anything like this!Trust me, I know. This isa prototype that just takes design cues from both versions of the Pip Boy and also some elements from the computer terminals in the games.
But wait! If you can make this much, why not just go ahead and build the 2000 or 3000A models? I’m not just going to buy a plaster cast of the FO3 PIP-Boy 3000 Clock and slap an iTouch in there. My goal is a functional device, not something that just looks functional. I do really want to make one of the models from the game, but until my budget expands, bringing completely accurate copies of the devices into reality is beyond my reach. On that note, should I win, making the PIP-Boys will be significantly easier. I’ve been planning my own open source hardware business for a while now, and a 3D printer or decent camera would help immensely. Vote for me and I promise you won’t be disappointed.
So grab a seat, pop the cap off an ice cold Nuka-Cola, and enjoy the Instuctable. By the end, you’ll have hopefully learned a lot more and will be able to design and build your very own Personal Information Processor Boy.
For those interested in getting started on the build, skip ahead to the section labeled Hardware.
Step 1: History and Features
So how did I design all this?
How did I go from staring at a few pictures of devices on a computer screen to holding a real device in my hands? Persistence, a clear schedule, and plenty of hot glue. By now, I think I’ve put about 200+ hours since November (not to mention the countless hours I spent playing Fallout 3 and New Vegas in the name of «research» ;). I broke down the project into major chunks and set aside certain tasks to be accomplished daily. I broke my tasks into two main categories: software and hardware. From there, I broke down everything into smaller chunks, coding a function here, adjusting the layout of a speaker there and so on. This helped me to avoid much of the mental fatigue and frustration that can come from building an intensive project. My daily goals were straightforward and reasonable for me to accomplish, and seeing the small leaps of progress were a confidence boost that made everything seem more manageable. But that’s not to say that I was perfect in my execution, quite the opposite. Many times I procrastinated for days at a time. I encountered software bugs that stumped me for hours. I simply stared at my screen many times, boggled at some hardware design problem, but I didn’t stop. My new favorite quote, which really applies to almost every aspect of life is, «Don’t give up what you want most, for what you want now.» It’s short and simple, but it strikes me pretty deeply. I want most to improve as an artist and engineer, to create ever more amazing designs, and to have my very own PIP-Boy, despite my urges to browse Reddit, watch Netflix, or sleep in. With the money I’ve spent on research and design over the last six months, I could have bought myself a shiny new iPad, but I can’t buy the satisfaction of knowing I took my desire and brought it into reality. It honestly may not look like much, but this little green box is far more valuable to me than the cost of it’s parts.
Okay, enough motivational mumbo jumbo, so what can the prototype PIP-Boy 2000+ do? Although many of the functions of the devices are purely for game mechanic reasons, there are still quite a few functions useful to those of us in the real world. Here’s a list of in-game features (based off of FO3 and FNV) and their status in development:
Automapping and waypoint navigation: (Partially Complete) Waypoints and simple GPS navigation is relatively easy, automaps without advanced laser rangefinders/sonar is not possible . Currently only latitude, longitude, heading, speed, altitude, and number of satellites used are displayed.
Moral status and local reputation: (Not Implemented) These can’t be automatically gauged, but the graphics would be trivial to add.
External interface to computers: (Partially Complete) The device must be disassembled in order to be reprogrammed, and no local data downloading is available for the time being. It would be neat to stick a decently sized flash drive in there, and even better if that information or the file system could be read on-screen.
Real-time health monitoring and feedback: (Not Implemented) there’s certainly no way to measure the health status of specific body parts or automatic notification of addiction, but I suppose the next best thing might be to add a heart rate monitor, although this would require the external chest strap. An accelerometer/pedometer to gauge steps taken and as a simple fitness measurement wouldn’t be too hard to add too.
Inventory status and item condition: (Partially Complete) I see no way for this to be automatic, but this version has RFID-reading capabilities, so some form of inventory management would be possible with unique tags for items, however crude.
Character level and experience: (Partially Complete) As the only real world task the PIP-Boy can be aware of is discovering a new location, that is the only way to «gain experience.» Although purely for fun and no practical reason, I could set this to gain experience/levels by traveling and have the user get to distribute skill points. Of course, you could always cheat since you have access to the code and could have whatever stats you wish, but that’s no fun ;) Perks are not implemented.
Ambient radiation measurement and level of irradiation: (Partially Complete) There is a small working Geiger-counter module, but this is also for fun and should by no means be used for situations in which serious radiation detection is necessary. Measuring how much of a dosage you have absorbed in RADs is also impractical.
Flashlight:(Complete) Just like in the game, the prototype has an «overbright» mode, although the LCD is not terribly bright, it does glow decently. For another version, I’m considering just popping in some high-power LEDs for some serious luminosity.
Time stopping/auto-targeting: (Not Implemented) Although awesome, V.A.T.S. is, for many reasons, ridiculously fictional, but I’d be interested to see what could be done with an IMU and a web cam/Kinect sensor strapped to a «weapon» pointed at a specially colored or marked target. I imagine a computer could determine the probability of a hit based on the current vectors of angle and acceleration of both the weapon and the target. This couldn’t be handheld, but would make for an interesting computer vision project.
Wrist-mounted: (Not Implemented) This version is handheld
Data storage and playback: (Not Implemented) No internal storage or audio playback for now, I’ve already designed holotape cases, but it’s too cost prohibitive to make them the way I want to make them for now.
Radio: (Not Implemented) This will be added at later version.
Clock with date and time: (Not implemented) Time and date can be read from the GPS, but I plan to use a RTC for when the GPS is disabled.
Screensaver: (Partially Complete) It doesnt come on automatically, but you can switch to a mode that displays the falling bomb screensaver that is pretty much identical to to the graphic from the first two games.
Unlimited battery life: (Not Implemented) If only fission batteries were real! This version runs on 6 humble AAs.
Step 2: Hardware
So before we get into the dirty work of building the device, I’d like to explain the main components and why I chose them.
Screen: The focal point of the PIP-Boy is of course the screen, and for this I needed something that could display all the data I wanted to at once. My first prototype used a 320 by 240 pixel LCD, but this was a graphically tight fit, so I upgraded a 4.3 inch 480 by 272 pixel LCD from 4D Systems (for reference, this is the same resolution/dimension as a SONY PSP). I picked this particular screen because it provided sufficient resolution for text and graphics in a decent form factor. It is a full color LCD, but I’m only using green colors on a black background as an approximation of the old CRTs. As an added bonus, this screen (like most of their products) has a built-in 16-bit processor (in this case, the Picaso GFX-2) that does all the nitty-gritty interfacing to the LCD and has a ton of built in graphics functions. This greatly reduces the complexity of most projects and is why I often use their displays. It even has a tiny built-in speaker and the ability to play .WAV files! The processor runs a proprietary language called 4DGL which is very similar to C or Processing, which makes it none too difficult to program. Alternatively, the screen can be controlled by serial commands from a host processor, but we wont be using that feature.
Auxiliary Processor: I chose to use an Arduino Duemilanove with an Atmega 328 as I’m familiar with using them and it can handle the GPS data more easily than the LCD. For now, I’ve used up all the available memory on the Picaso processor, so the Arduino picks up the slack and will also do more of the hardware interfacing in the future.
GPS: I chose the Adafruit Ultimate GPS because it’s small, high quality, cheap (for a very decent GPS) and well documented like all Adafruit products.
RFID: I chose the RFID-12 from Sparkfun, as it’s a tiny self contained module with a built in antenna, and it’s dead simple to use. Just power it up, hold up a tag, and out pops the ID over 9600 Baud serial. This is used as a security feature for this version, but I plan to upgrade it to «equip/unequip» items. For what purpose? Nothing practical, but it’d sure be cool.
Input: The main input is a tiny 8 position rotary switch that I found browsing the Electronic Goldmine. Even though it’s surplus, it’s still a really high quality mil-spec component with a solid metal body and gold plated contacts for Add Tip Ask Question Comment Download
Step 3: Building the Main Circuit
Note: I apologize beforehand about the inconsistencies of the photo quality. I only had the opportunity to use a decent camera for a day, and used that time for the final product shots. My only personal camera is my cell phone, thus I had very little control over the quality :/ Also, since they’re not utilized in the code at this point in time, I won’t be detailing attaching the rotary encoders.
Main Board:
I’m using the the Radio Shack mini protoboard for the main interconnect between the Arduino, hardware and LCD. First, solder 9 of the 10k ohm resistors to one of the power buses (this will be VCC at 5V). We’ll mostly be making power and signal connections from this board to the sensors and Arduino, as everything is modular.
RFID:
-Solder the module to the breakout board.
-Solder the pin headers to the breakout board.
-Using female jumpers, make four 3″ long connections to the main board
-Connect to of the wires to GND and two to VCC
-When attaching the module to the female headers, connect the module’s VCC and RST pins to the 5V output and the module’s GND and FS pins to the GND wires
GPS:
-solder the male header to the board
-solder the battery holder to the board
-make connections from the main board to the GPS with one line for VCC and one for GND
Battery Pack:
-Keeping the black plastic tube down the wires, solder the wires to the inside of the unscrewed plug
-seal wires with hot glue
-screw black plastic plug cover back on
Key Switch:
-test with a multimeter to find out which contacts form the switch (since this is a surplus part, they might be different from mine)
-solder two 3″ long wires from the contacts
-splice the VCC line of the battery pack in between the plug and attach the wires to the switch wires
Illuminated Switch:
-solder a wire to the + end of the led contact and a wire to the — end
-solder the negative LED wire to the main board GND
-solder the positive LED wire to a 220 ohm resistor on the main board
-solder the other end of the 220 ohm resistor to a 4″ long wire (solid core) extending off the board to a female header (output from LCD)
-solder a wire to each end of the switch contacts
-solder one end of the switch contacts to one of the pull-up resistors on the main board
-solder another wire to that last connection to a 4″ long wire (solid core) extending off the board to a female header (input to LCD)
-solder the other switch contact wire to GND
Rotary Switch:
-solder a 3″ long wire to the big center common pin on the underside and connect it to the GND on the main board
-solder a 3″ long wire to the pin labeled «1» (cover in heat shrink tubing or hot glue to prevent a short)
-repeat for the next 7 pins (the contacts are pins 1-8)
-solder the pin «1» wire to one of the pull-up resistors on the main board
-repeat for the next 7 pins
-solder a 4″ long wire (stranded core) extending off the board to a female header (input to LCD)
-repeat for the next 7 pins
Hooray! That’s it for soldering. Since the speaker and rotary encoders aren’t used for now, we’ll just be popping them into the front panel unwired.
Step 4: Making the Case
So how’s it made? I used Adobe Illustrator to edit and design the case. I then converted it to the necessary format (I’ve done this already for you and included it at the bottom) and sent it to Ponoko to be lasercut. Unlike many lasercut cases, I decided not to use the typical tabbed edge design. Instead I used multiple layers of frames with the middle sections removed and just four simple holes in the corners for screws. This method creates more excess scrap when finished, but I find it more attractive than the tabs. I included images of what the various layers and side panels look like, but the real files look much more plain.
Back Plate Design:
The LCD mounts into back plate flush as it too (from the top of it’s PCB) is only 1/8″ thick. The sides also have very long slots into which the side panels mount.
Middle Plate Design:
The middle plate serves as a retaining frame for the polycarbonate sheet along it’s edges, and also provides the sides slots for the panels as well.
Cover Plate Design:
Just to make everything more aesthetically pleasing, I wanted the cover plate to look nice. Its functional purpose is to retain the polycarbonate sheet in place and provide holes for the knobs to attach to. The inner hols for the screen and speaker are wider than the heads of the screws themselves, so the screws will appear to be «counter-sunk» into the case. Nothin’ much else to say, the speaker cover is a tiny little Vault-Tec logo and there are a few symbols etched near the rotary encoders to mark their future purpose as input knobs.
If you’re going to use Ponoko to make your case you’ll first need to make an account. Once you’ve properly registered, log into your account and go to My Designs. Upload the files I’ve provided. The project uses a single sheet of P3 (15″x30″) 3mm glossy hardboard. You can use whatever material you like so long as it’s 1/8″ thick, but I preferred the hardboard as it’s the cheapest option :P
If you received your case from Ponoko, you’ll first have to remove the adhesive paper that covers both sides. The cardboard flap that the board is shipped in makes a wonderful spray painting surface, so that’s what I used.
Front and back plate construction:
1. Sand until the hardboard is no longer glossy. Wipe off excess dust.
2. Take the boards to a well ventilated area for painting.
3. Spray a nice even layer of primer. Allow to set according to the instructions on the can.
4. Spray the first coat of regular paint. Allow to set
5. Spray three more additional coats from alternating directions each time. (top->bottom, right->left etc.)
6. Allow to dry.
I don’t have any shots of the final painted plain sheets, but just feel free to paint until you achieve the desired color.
Attachments
Step 5: Software Overview and Programming
UPDATE: For anyone interested in the 3000 model code from my other youtube video, you can find it here as oldPip3k.txt. This only displays various graphics if you have them and interfaces with an arduino for reading switches, but lacks any functionality compared to the handheld version. It’s old and clunky, but you’re free to see it now!
Now that you’ve built it, it’s time to bring your PipBoy to life. Failed your G.O.A.T test? Not a problem! Follow these next few steps and you’ll be a bonafide PipBoy Programmer in no time!
So what’s actually going on inside both processors? On the Arduino side, not a whole lot. The Arduino is just parsing the NMEA data from the GPS, reformatting it into a fixed packet length of around 45 bytes and spitting it out on serial to the uLCD43’s Picaso processor. If you take a look at the 4DGL code, thing seem a lot more complicated, but the majority of the program is just writing all the graphics for the display. The 4DGL program mostly just waits for the packet from the Arduino and then updates the display information on the Navigation tab for the user to look at. I commented a lot of my code, so it should be pretty straight forward if you’re trying to read it. I hate when people provide lengthy code, but fail to comment properly, leaving readers to struggle. What’s the sense in sharing your program if you’re not going to share it with users of all skill levels? So hopefully there is no mystery to my code and you can learn from it. I can’t really claim any credit for 90% of the Arduino code as it’s mostly from the example Adafruit Library. The 4DGL code is however entirely my own labor of love and due to being 1000+ lines of code, I wont display it as an image here. It’ll open fine in any code editor like Notepad++ if you just want a peek without having to download the 4D systems’ suite. It’s very much like the Processing language, so it should be relatively easy to follow.
To get started you’ll need two different programs:
Download and install the programs to your computer (Unfortunately the 4D software is Windows only, so Apple and Linux users will have to find a Microsoft machine for these next steps)
I extracted the images and sounds directly from my game files on my computer so I can’t legally redistribute them. I wouldn’t want to have to delete this Instructable for silly legal reasons :( So I won’t detail how to extract them either, BUT it is very easy to do should you search elsewhere. I will still show you how to properly put graphics and sound files onto the uSD card for use with 4D systems LCD and OLED screens.
Before we can upload a bunch of images to the micro SD card and plug it into our screen, we’ll need to format the card. According the the Graphics Composer user guide, you need to do a full format, so uncheck «quick format» and go for a stretch or snack. My computer took about 5 minutes to completely format a 2GB card.
Loading images onto the micro SD card:
1. Fully format card
2. Open Graphic Composer Software (4D Workshop—>Tools—>Graphic Composer)
3. Click the «add» button at the bottom left corner of the software
4. Select all the images you want to add and hit OK
5. Once all the images are loaded into the software, click the build button
6. Select the first option (4DGL, SGC Picaso — GCI — FAT Selected Folder)
7. Make sure the output folder is your micro SD card (usually drive D:\)
8. Click ok and double check the SD card drive to see that the files were downloaded (two files called «.gci» and «.dat» on the card)
9. Open the «.dat» file and save in at another location on your computer
10. remove the card from the computer and pop it into the micro SD slot on the LCD
There are multiple ways to diplays images using 4DGL, but I’m using a function that requires you to name the images by it’s index position in the «.dat» file. So the first three images in that file are thus indexes 0, 1, 2 etc. This will make more sense when you refer to the code in the included program.
Compiling and loading the 4DGL code to the LCD screen:
1. Download the attached file «PIP4DGL»
2. Open the 4D workshop software
3. Change the «Platform» in the toolbar to uLCD-43PT_GFX2
4. Plug in the board to USB to Serial board (TX to RX0, RX to TX0, VCC to 5V, GND to GND, and RST to DTR
5. Make sure the output is set to the right COM port of the tab next to the Compile and Download Button
6. Wait for the colored circle on the toolbar to turn blue (should only take a couple seconds)
7. Check the «Destination->Flash» option on the toolbar
8. Click the «Compile and Download» button
Compiling and loading the code the Arduino:
Before loading the code to the Arduino, we need to follow the instructions from Adafruit here