Under 1 hour to assemble, 3D printed circuits, no wires, no solder, 802.11 b/g/n client or access point built in, SPI/I2C, extra 5 GPIO w/PWM and 1 analog input, under $20 in parts
When we first invented F-Electric, we wanted to get the breakthrough into your hands quickly, and enable you to start making amazing things. As we’ve learned through your projects and questions, any new material, while enabling new ways or things to make, also brings with it a new learning curve, especially when dealing with a large variety of 3D printers and ideas. We hope this tutorial will provide you with tools to 3D print the electronics you imagine using F-Electric. Follow along to learn how to easily make a working, programmable, Arduino-compatible, WiFi connected, color touchscreen and microcontroller for under $20, all parts included.
You will also need a small amount of Functionalize F-Electric filament (the circuit print uses 6 grams), which is available as filament in our store, and a conductive paint to use in place of solder to make connections. We do not sell a conductive paint yet, but we will be adding it to our product line soon. Until then, you can use most silver conductive paints. You should probably stay away from the carbon paints for this purpose, but silver should work and copper might. We do not recommend an alternative conductive filament, but if you try this with one, we’d like to hear about your results.
What a difference a week makes
This project actually started as an internal effort to improve our production through automation. Recently, we decided to build some factory control equipment, and thought “what a great opportunity to put F-Electric to the test and maybe make an example in the process”. I started working on this design a little over a week ago, and am now ready to share the first rev of a component we will use along with what new things I’ve learned about 3D printing circuits with F-Electric. I hope you will find this write-up helpful.
What went wrong – why you shouldn’t trust small things to your slicer
Anyone who’s been 3D printing for more than a few weeks has almost surely chosen their favorite slicer. Whether for you it’s Simplify3D, Slic3r, Cura, Makerware, Pronterface, or another package, they all work similarly. In essence, they “slice” your design file, usually represented as a 3D model in the form of an STL file, into many layers, or slices, at the resolution you request. On each layer, the slicer also converts that 2 dimensional slice into the smallest, most efficient path for the extruder to create the detail you’ve modeled. Unfortunately, the criteria for “most efficient” for most slicers is the best it can do without hopefully not messing up visuals too much. Combine that non-deterministic slicing with the standard .1” or 2.54mm pitch, or space between pins, which is the most common breadboard-friendly pin distance, and you have really no room available for printer or slicer optimization. As a result, if you don’t design your model in a way that constrains the slicer, you may end up with tiny errors that cause short circuits, holes that are plugged, or possibly even thin traces that don’t print.
When I started designing the touchscreen circuit model, I began with the pins that I had previously used in the 3D printed Arduino light sensor project (here). While I got a good pin about 90% of the time out of that design, which seemed to result in mostly successful prints on the few pad light sensor, I found that when you’re printing a board with 44 pin pads, those are not good odds. I went back to the drawing board to see if I could come up with a pin pad design that gave a reliable hole and sidewall without shorting to the nearby pin, again and again. While I actually came up with a design that I’m very pleased with and has printed flawlessly since finishing it.
The key to what I learned, which definitely applies to 3D printing electronics, is that sometimes by designing parts that can reasonably be printed only one or two ways and taking control of the print head path, you can achieve the best possible detail. Even though it’s a technique you can apply to 3D printing electronics, it could also work for any very small details you wish to print in any material.
When trying to figure out ways to print more reliable trace connections and pin holes, the first thing I did was what I’ve recommended before, to use a trace width that is a multiple of my print nozzle size. The size I chose for this design, 0.4mm or 0.8mm, should work well for nozzles ranging from 0.25mm to 0.5mm. Above 0.5mm, you may start to have difficulty getting the detail needed, but we would love to hear your results in either case.
With multiples of 0.4mm in mind, I used 0.8mm trace widths for this design. I have also used 0.4mm trace widths in other designs, such as the 3D printed dice (here) and 3D printed spaceship ornament (here) when I needed or could tolerate higher resistance. Generally, I’ll mix 0.8 and 0.4mm traces comfortably in a design.
Making holes – reliably
In focusing on more reliable pin pads, I needed more control over the pin pad holes, and instead of modeling them as I would ideally want them to be, which in the Arduino light sensor shield is an oval inside an oval, I decided to put every little 0.4mm line that I wanted the head to print, exactly as I would want the slicer to slice, and separate parallel traces for width by a 0.05mm gap, which forced the slicer to pay attention even though the gap was so small they actually printed together.
My first attempt at a reliable pin hole was to make the hole a circle in the middle of the two sides of a 0.8mm trace, which actually didn’t work as well as I’d hoped. The pin pad simply didn’t have enough structural strength and the sharp turn from a straight line to a circle sometimes caused a small blob of hot F-Electric to touch the nearby pin pad, causing a short circuit.
I decided to make two changes. First, I increased the number of 0.4mm parallel lines in the pad to 3 for strength, resulting in 3 – 0.4mm traces, separated by 0.05mm gaps. For the hole, I cut out the middle trace altogether and the outer two traces bow out into the smooth transition of an oval. Once I switched over to this design, then modeled a sacrificial tower next to my whole model instead of relying on the slicer’s solution to prevent two heads from interfering (purge wall), the board printed flawlessly and repeatedly. Each print created 44 well defined pinholes, every pin of both the NodeMCU V1.0 board and TFT touchscreen fit smoothly into its socket each time. Now I was ready to really lay out the circuit.
What about when traces cross?
Inevitably, when working with a number of pins and routing connections on a board, you will encounter traces that must cross in two dimensions, but are not allowed to touch each other. In normal, 2.5D, layered circuit design, you get around this problem with a two or more-layer board. In this design, I took advantage of the fact that we’re 3D printing in a structural material and effectively implemented a two-layer board that can still print on a single head printer by bridging, which is when the head jumps over a bridge from one side to another without touching what’s below. I found that the minimum bridge height that I could count on to avoid short circuits was 1mm.
The first file is intended for single head printers that will use a pause to change filament when switching from the insulator to the conductor. On this design, that happens at 2.4 millimeters. You can either insert a pause into your print to change filament, which is available in some slicers, or you can start printing with insulator, keep an eye on your print and manually pause it after 1 or two layers of the printer starting to print the actual circuits,and then change filament to conductive. Being off by a layer won’t affect the functionality of the design, as long as you’re sure to wait until the printer really starts printing the circuits. Don’t mistake the printing of holes for the pin pads as circuits. Be patient, and it will be clear when the circuits really start start to print. It will also be at the same time as the mounting posts for the touch screen start printing as well. To understand the process in more depth, you can watch this video on how to print the flashlight on a single head, which works the same way.
For dual head printers and slicers that allow you to assemble multiple STLs into one part, you will want more control by using the second download with two part files.
Now that I had a design that repeatedly printed as intended, it was time to put the NodeMCU and the touchscreen in place. Before populating the print, however, there were still a few things left to do. To ensure that the print was as good as it looked, I cleaned it up to ensure no straggling bits of plastic were left anywhere and checked every connection with an ohmmeter. In some prints, I have found occasional tiny shorts in the bridges, which can be easily cleared by simply passing a bent pin tip through the bridge.
Is it conductive enough?
When measuring with the ohmmeter, one thing I noticed before finishing the build (and you will as well if you follow along) was that the reading for each pin to its connected pin was somewhere around 1 kohm for all connections, depending on how hard I pushed with the probes. If you get this reading, do not worry, this is normal at this stage, and there are still two more things left to do, which will lower that number. The higher than desired resistance at this stage is the combination of both the volume resistance of the material as well as the surface resistance on the small point of contact to the probe of your ohmmeter. The way around this is by using a conductive paint or glue at each pad, more easily applied than solder, which will get through the surface resistance and make a good connection to the component pin, leaving the pin to pin connections in this design averaging about 100 ohms. While we will soon provide a reasonably priced conductive paint that will work well for this task, you can currently use many of the silver paints available. I have not tried the carbon-based paints for this purpose, as I believe they will not have the necessary conductivity.
If you’re worried whether or not 100 ohm connections are good enough for circuits, the answer is that they are for some, most that carry signals, and they are not for others, such as many that carry power. In the past, I’ve generally printed ganged traces to lower the resistance when moving power across the traces. Although that works to a point, it turns out to be easier to single out the few traces that you’d like to have more conductivity on and use the same paint that we used on the pads, to simply boost the conductivity of a couple traces. If it’s necessary, you’ll usually care most about power and ground, though you may choose to boost the trace going to the LED backlight of the screen as well. Personally, I like the brightness level without it. While such a boosting trick was not necessary on the ATtiny85 dice project, with the touchscreen, I found some conductive enhancement on the power lines important to get ample power from the NodeMCU board to the touchscreen. To ensure that it worked well, I simply lined both power and ground over the top with a couple passes of our silver-copper paint, which took no more than a minute or two.
Flashing your NodeMCU using Arduino
If you’re following along, you’re almost ready to put the hardware together and have a complete, WiFi touchscreen ready to host an IoT user interface, serve as a thermostat, dimmer, or controller of local or remote devices, sense surroundings, and generally do your bidding on the Internet of things.
While you wait for your first touches to the pins and power traces dry and before you put the board into its 3D printed socket, you’ll want to install the Arduino IDE on your computer as well as support for the NodeMCU board. Then you’ll want to load your NodeMCU with the sketch that you expect it to have when your version of this device is complete. You’ll want to do all this before the next step, because once you’ve assembled the device, you’ll need to disassemble it (to disconnect connection to the touchscreen) in order to flash it again through the micro-USB. I understand it is possible to configure it to install new sketches over the WiFi connection, but I haven’t done so yet, so that will be left as an exercise for the reader or future post.
To make it easy to follow along with me, and if you are willing to disassemble your first experiment to make it easy to reprogram for your own device, here is every link you need to setup Arduino on your PC, install the ESP8266 drivers, install the open source Adafruit GFX graphics library that can drive the touchscreen, install the open source touch drivers, and have everything you need to put touchscreens in your own 3D printed projects.
Install the latest Arduino IDE to your PC from here: https://www.arduino.cc/en/Main/Software
Install support for the ESP8266 to your PC from here: https://github.com/esp8266/Arduino/releases
Install the Adafruit GFX library to your Arduino libraries folder from here: https://github.com/adafruit/Adafruit-GFX-Library
Install the spapadim XPT2046 library to your Arduino libraries folder from here: https://github.com/spapadim/XPT2046/archive/master.zip
Install the final driver code and test programs kindly written and published by NailbusterSoft here: http://nailbuster.com/nailcode/tft28esp.zip
I also recommend you read the excellent Nailbuster Software page on a breadboard version of the project here: http://nailbuster.com/?page_id=341
When you’ve installed the Arduino software and driver libraries to your PC, flashing your NodeMCU board is as easy as connecting the board to your computer with a USB to Micro-USB cable, selecting the board type in the Arduino IDE, loading the sketch you’d like to run, and selecting upload from the “sketch” menu. If you’d like to try it on a breadboard first to be sure it works before trying your 3D printed part, we use the same pinouts as David from NailBuster Software used.
Putting it all together
At this point, we are ready to put everything together and “Make it work!®” In order to ensure that we get good contact and adhesion across all the pins, we’ll want to poke a safety pin through each hole with a paint cover, and place a small wet drop of conductive paint onto/into the hole of each pin. No need to go overboard on filling the hole. First prepare the pinpads for the NodeMCU and put it into its socket in the orientation shown, pressing down firmly to leave 1mm of space and no more under the header. Next, prepare the pin pads for the touchscreen in the same manner and place the touchscreen into its socket in the same way.
Really. The next thing to do is have fun watching your paint dry. I find blowing it with a blow dryer helps, and I’ve used parts within 10-15 minutes sometimes. Not stressing the pins and waiting for long enough for the paint to dry well is really all you need to do. Once it has dried, plug in a micro-USB cable and imagine the possibilities! We look forward to seeing what you make!
This work by Functionalize Inc. is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.