In 1977, NASA launched the spacecraft Voyager 1 into the void. Some circumstantial planetary alignment meant that the probe was slingshot past our solar system, set on a course of interstellar exploration. Forty years later, the Voyager 1 mission now marks the furthermost point of humanity’s reach into our universe. Still transmitting data back to earth, Voyager 1 pushes the boundaries of human exploration with each passing second.
I have a personal fascination for the Voyager missions, and wanted to make a display that captured their spirit.
When the display flashes a number, it represents the distance in miles between Voyager 1 and earth, an objective measurement for the possibilities of human imagination.
The display pauses for a brief moment, and then updates.
Add a Teacher Note to share how you incorporated it into your lesson.
Step 1: Materials
(3) x 4 Digit 7 Segment Display($ 30)
Since voyager is currently hovering at over 13 billion miles, 11 digits are needed to represent that figure in decimal / mileage form. Depending on how you want to represent the distance, the number of digits needed could change. Since Voyager is still traveling, and these Adafruit displays come in 4 digit sections, a 12 digit display made the most sense. An added benefit of the linked displays are that they are by no means pure 7 segments and actually have plenty built into the module to allow for the communication of data through the I2C protocol. This means that in order to actually control the display you only two pins, SDA and SCL on your microcontroller. With a less sophisticated module, the numbers pins needed could rise quickly.
Make sure you have a breadboard or some sort of way of nicely connecting wires. I but both the brains and the board on the same breadboard so mine was decently big.
Make sure to have some wire at hand to make the necessary connections! There's not alot of wiring involved, but color coding definitely can be useful.
The Brains: ($ 9.00)
Various Arduino boards, or a raspberry pi would also work well. Just keep in mind that for this project, whichever board you choose must be able to speak the I2C protocol and have pins available for SDA (serial data) and SCL (serial clock).
Also the source code I wrote was using the Arduino IDE, but porting that code over to different devices shouldn't be too hard. The reason I wrote with the Arduino IDE was so that I could use Adafruit's convenient library for the 7 segment modules.
Step 2: Getting the NodeMcu to Talk to Computer
Whatever microcontroller you end up going with will have a different method of a connecting to you specific computer, but for the NodeMcu that I used, here's how you connect it to to work set up with programming in the Arduino.
First you need to get the relevant driver on to your computer...
Here's a link:
Once the driver is installed, your computer should be able to recognize the development board.
Now that the board is connected, you are ready to start programming the board and hooking up the displays!!
Here's a really good instructable for downloading the necessary libaries that the Arduino IDE needs to program the esp8266 chip! Once you've followed these instructions, try running the blinking light example that comes with the library!
Step 3: Wire Everything Up!
Once you can successfully talk to the board, you are ready to connect the display components in a manner of your choosing (I used a breadboard).
Since the adafruit buildpacks do the heavy lifting, thankfully the wiring isn't too bad at all!
All you have is a positive and negative wire for each display that must be connected to ground and 3.3V on the board respectively.
There will also be a SCL and SDATA wire for each display and those all need to be connected to the SCL and SDATA wire on the board. Since the displays are actually communicating over the I2C message protocol, the board is able to save on wires and communicate through addresses instead. If you use the same buildpacks that I did, setting different addresses on a display is done through a solder jumper on the back on the display and is nicely documented here.
Thats it! Now you are ready to load the program on to the board!
Step 4: Run the Software!
Attached is the Arduino Sketch used to populate the display!!
Things to change:
- Enter in the appropriate wifi ssid and password in the relevant section. In complete honestly, I'm not sure of the security implications of this, but operate under the assumption that wifi credentials are in plaintext.
- Depending on how you choose your display module addresses, the current values that are hard coded in might change. If you aren't getting anything from a particular display or your numbers are showing up out of order, double checking that each address is hard coded with jumpers and correctly referenced in the code.
- The core code of the display is the manipulation and appropriate propagation with 0s. This is all done with the Arduino library that adafruit wrote for their displays! Make sure you've installed the relevant library at https://github.com/adafruit/Adafruit_LED_Backpack as well as Adafruit's large GFX library.
- The other piece of code is an HTTP GET request to a Heroku web server. That web server is a web scraper I wrote that gets the relevant information from NASA's JPL website. Just a fair warning that the scraper is a bit slow and a small change on JPL's end has the potential to cause problems with it. Here is a link to the source.
Step 5: Finished!
Once you've changed the relevant code and double checked that the wiring is correct, upload the program on to the board. With any luck, you should see Voyager's distance start flashing/updating on the display! I've found that sometimes the board has trouble connecting to wifi, if you are getting gibberish on the display, it can be useful to open up the serial monitor and make sure that the wifi is connecting properly. Requests to the server can time out as well. If things really are struggling, pushing the rst button on the board can sometimes solve the issue.
Attached is a video of the finished product!!