Boron Lander

This is my first attempt at building one with cellular connectivity, which is provided by the Particle Boron, and hence the name. I previously built a similar version using the Particle Photon 2 which provides connectivity over Wi-Fi instead of cellular.

As I have built these free-formed circuit sculptures over the years, I have come to realize that the lander or space inspired formfactor works really well with this technique. The brass or copper interconnects are used for electrical connections as well as the structural elements. You can possibly 3D print the structure and stick a circuit board inside of it – but where is the fun in that?

Please understand that this is not a step-by-step tutorial, but rather a documentation of how I went about building the lander. There are an infinite number of ways in which one can go about building something like this – based on their skill set, available resources, desired aesthetics, etc. I encourage you to use this documentation as a reference guide to help you come up with your own version, rather than trying to replicate it as is.

(*some of the product links include Amazon affiliate links)

Parts list

• Particle Boron 404X or your favorite MCU board
• 1.3” 240×240 IPS TFT ST7789 display
• SHT31 sensor breakout board, or your favorite sensor
• 14250 Li-Ion battery
• Linx ANT-LTE-SP610-T antenna
• uFL pigtail
• 20 AWG brass or copper rods for the frame
• 14mm brass discs for the landing pads

Block diagram

There are essentially four major components in this design. The MCU board, display, sensor, and the battery. The display operates at 3.3V and connects to the MCU over SPI, while the sensor talks over I2C. You can choose to power the project with a battery or simply over USB. If you are using the Particle Boron, you’ll also need a cellular antenna.

Controller

At the heart of this sculpture is the Particle Boron 404X, which is Particle’s cellular IoT devkit in a Feather form-factor. It comes preinstalled with the Particle Device OS and provides connectivity to the internet over the cellular LTE CAT M1 network. This particular version only works in North America and cellular data is free for your first 100 devices.

Developing on the Boron is very similar to working with Arduino, ESP32, or the RP4020 based boards. You’ll however need to use the Particle Workbench to write, compile, and upload your code instead of the Arduino IDE. If you are new to the Particle ecosystem, I highly recommend getting yourself a Particle Photon 2. You can start with simple projects and work your way towards building something more complicated.

If you are not interested in using a Particle device or it isn’t available where you live, you can always adapt this project to use a different MCU board. ESP32 or the RP4020 based boards are good alternatives. You’ll need to modify the code to work with them. You will also lose the webhook integrations that allows one to fetch the weather forecast and sunrise sunset times. You can find other online documentation to figure that out for your platform or simply use it without the internet.

I designed the Boron back in 2017 when we launched the Particle Mesh product line. While the Mesh project has been deprecated, the Boron is still our flagship cellular IoT dev kit!

Display

I’m using a 1.3” 240×240 16-bit full color IPS TFT display based on the ST7789 controller. This display has a really good viewing angle and the images appear very crisp. The display is widely available and comes in various sizes and pixel density. These work at 3.3V and communicate over SPI. There are a couple of good open source drivers for them available. Both Adafruit’s ST7735 or Bodmer’s TFT_eSPI work well. I’m using Adafruit’s library for this project.

Sensor

I made a small breakout board for the SHT31 temperature and humidity sensor. You can use other off-the-shelf breakout boards for this sensor as shown above or use a completely different sensor, like the BME280.

Power

⚠️ Please use these batteries with extreme caution as improper use will result in fire 🔥

The sculpture is primarily powered by two 3.7V 300mAh 14250 sized (sometimes called ½ AAA) Li-Ion batteries connected in parallel. The Boron has a built-in Li-Ion battery charger, so the batteries are directly connected to its +Li pin. The batteries are charged by simply powering the Boron over USB. The Boron also has an onboard battery fuel gauge that reads the voltage and state of charge of the battery.

I recommend using only one battery, as connecting two Li-Ion batteries in parallel without matching them is extremely hazardous! These batteries also do not have any protection circuit on them which means if there is an accidental short circuit, it will result in thermal runaway. If you are uncomfortable with working with these batteries just use USB for power or use a folded LiPo battery with build-in protection like this one.

Antenna

The antenna that ships with the Boron was too big for this project, so I ended up using a Linx PCB monopole antenna designed to work on the LTE-M bands. The antenna actually requires a large ground plane to work properly, but in this case, physics was sacrificed in the name of art. (It still performs remarkably well based on my observations.) I also love how its gold plated edges work really well with the aesthetics of this design.

I soldered a uFL pigtail to the antenna and routed it to the Boron.

Schematic diagram

Pin connections

The display pin names suggests that it connects to the (SCL/SDA) I2C pins, but that is incorrect, and it actually connects to the SPI port. I’m not sure why the manufacturers decided to name it like that.

Display GND – Boron GND
Display VCC – Boron 3V3
Display SCL – Boron SCK
Display SDA – Boron MOSI
Display RES – Boron A5
Display DC – Boron A4
Display BLK – Leave unconnected

The sensor board has built-in pull up resistors on the SDA and SCL pins. If yours does not have that, please add 4.7K pull up resistors on SDA and SCL pins separately.

Sensor VIN – Boron 3V3
Sensor GND – Boron GND
Sensor SCL – Boron SCL
Sensor SDA – Boron SDA

Battery positive – Boron Li+ pin (via a switch)
Battery GND – Boron GND

Construction

I always start by putting together the design on a breadboard. This allows me to finalize the parts and connections. In the below layout, you can see that I also had a plan to add a GNSS receiver and a UV sensor which I later decided to not include.

The frame is made out of 20 AWG brass rods. You can also substitute it with copper wire of the same gauge. I made a quick video on how you can turn a brass or copper wire into a straight rod. I designed a true to scale template using Autodesk Eagle to help guide the construction. I use a pair of flat nose needle pliers to bend the rods and a diagonal cutter to cut them to length. The frame is connected to the GND net, so routing becomes a lot easier. You can download the PDF version of the template here.

After measuring, cutting, and bending the rods using the printed paper template as a guide, I hold them down on the sheet with a masking tape. This is a very cheap and effective technique to solder simple shapes. You can also design 3D printed templates to accomplish the same.

Remember to apply flux on each joint before soldering and keep your solder irons’ tip clean. I use a water soluble flux pen which makes the application very easy. I then clean the joint with a fine grade steel wool.

The rest of the interconnects were done using the same technique. I also used rather rudimentary makeshift soldering jigs with scrap PCBs to align the interconnects.

Always a good idea to test the subsystems as you go!

The landing pads are small 14mm brass discs that I purchased over at an etsy shop. You can also make your own by punching discs out of 0.5mm thick brass or copper sheet. Remember to solder the pads at the very end of the build. If you do so in the beginning, you might end up with a wobbly sculpture!

Firmware

A lot of the heavy lifting is done by Adafruit’s device libraries. They put out a ton of really amazing open source device libraries and hardware. Please consider supporting them by purchasing their products! I’m using the Adafruit ST7735 and GFX libraries for the display, and the SHT31 library for the sensor.

Complete source code for this project can be found on my GitHub.

In addition to downloading the firmware on to your device, you’ll also need to setup the Particle Webhook integrations on the Particle console to fetch the weather forecast and sunrise/sunset time data.

Setting up Particle Webhooks

You can find the complete documentation on Particle Webhooks here.

Essentially Particle Webhook allows you to connect your Particle device to different services on the internet. In this project we are relying on the Webhooks to fetch and parse the weather forecast and sunrise/sunset times and sent it back to our device. Everytime we do a Particle publish, we trigger the associated Webhook which in turn returns us a nicely parsed data string. We fetch this data by subscribing to the associated webhook response. All of this magic happens asynchronously in the background and you do not need to actively manage it!

If all of this sounds confusing or overwhelming to you, don’t worry! You can follow some of the documentation on the Particle’s website or join the online community to find answers.

Setting up webhook to fetch sunrise and sunset times

We will be using the ipgeolocation.io’s Astronomy API to fetch the sunrise and sunset times. You’ll first need to get an API key from them. Create a free account and follow the instructions on their website to get an API key here.

Now goto to Integrations in your Particle Console. Click on +ADD NEW INTEGRATIONS.

Setup the webhook as follows. Under the URL block paste the link with your API key and location.

https://api.ipgeolocation.io/astronomy?apiKey=123456789&lat=37.89&long=-122.48

To check if the your API is working, you can paste the above link (replace 123456789 with your API key and plug in the desired latitude and longitude) in your browser. You should get a JSON response similar to this:

{
"location":{
"latitude":37.89,
"longitude":-122.48
},
"date":"2023-09-04",
"current_time":"18:28:22.248",
"sunrise":"06:58",
"sunset":"19:25",
"sun_status":"-",
"solar_noon":"13:02",
"day_length":"12:07",
"sun_altitude":8.83184579927521,
"sun_distance":150150216.08592105,
"sun_azimuth":262.6648711229167,
"moonrise":"15:46",
"moonset":"-:-",
"moon_status":"-",
"moon_altitude":18.973028493232043,
"moon_distance":371243.2836966175,
"moon_azimuth":152.358996841901,
"moon_parallactic_angle":-24.38493925298245
}

Goto the Advanced setting and select custom under the query parameters.

In order to extract just the sunrise and sunset times, we will create a parser under the Response Template which can be found under the advanced settings. This way, only the sunrise and sunset times are sent to your device instead of the entire JSON response. If you are interested in fetching and displaying other parameters like the moon rise times, modify the response template accordingly.

Hit save and your webhook should now be setup.

Setting up weather forecast webhook

Goto to Integrations in your Particle Console. Click on +ADD NEW INTEGRATIONS.

We will be using the weather.gov’s free API service to fetch the weather forecast data. You will have to adjust the URL with grid points for your location. It is currently set to fetch weather for San Francisco.

Create a webhook template to parse the relevant information.

{{properties.periods.0.name}}~{{properties.periods.0.temperature}}~{{properties.periods.0.shortForecast}}~{{properties.periods.1.temperature}}~{{properties.periods.2.temperature}}~{{properties.periods.2.shortForecast}}~{{properties.periods.3.temperature}}~{{properties.periods.4.temperature}}~{{properties.periods.4.shortForecast}}~{{properties.periods.5.temperature}}~{{properties.periods.6.temperature}}~{{properties.periods.6.shortForecast}}~{{properties.periods.7.temperature}}~

Hit save and your weather Webhook should now be all set.

Thoughts on building your own lander

If you are new to the world of microcontrollers, electronics, or embedded systems, this project might not be the best place to start. I’d recommend getting yourself a Particle Photon 2 or some other MCU dev board like the ESP32 C3 Wroom or Raspberry Pi Pico. Learn by building simple breadboarded projects with displays and sensors. Next learn to solder together simple brass frames and shapes. After you feel comfortable with putting together simple projects, gradually move on to combining free-form soldering technique with electronics.

If you found this documentation useful, please consider supporting me on Patreon or buy be coffee! Thank you!