This will always be the coolest thing about having a 3d printer. Within an hour of my wife asking for a tool to help stamp down home made baby food into an ice cube tray for freezing, we had a custom ready to use tool.
We needed some coasters for our dining room table, so why not 3d print some. I saw this really cool design on Etsy for these snail coasters and decided to recreate them with Shapr3D on my iPad and print them in wood filament. A little staining and varnish with some felt feet and they were good to go.
The latest 3d printing creation — a giraffe themed desk pen cup for my wife. A little late for Mother’s day due to us moving, but better late than never, right? I wanted to make something that can help her feel a little closer to our daughter, while still being a little practical, hence this desk cup pen holder thing. Why giraffe themed? She loves giraffes and that’s what our nursery is. And why not throw some 3d prints of our daughter Aurora’s footprints while we’re at it.
This project went together pretty quickly, most of the work being the 3d printing. I had a circuit playground express from Adafruit on hand and knew that’s the board I wanted to use (since it had the onboard Neopixels to add a nice glow). With that in mind, I started with some measurements and building the main pieces in Shape3D so I knew they’d fit correctly when working with real-world objects. Once the base mesh was done, It was over to MODO + Zbrush to create the main giraffe piece. The base mesh for the giraffe was done in MODO and sculpted in Zbrush, using the STL from Shapr3D as a guide so it would still all fit together correctly when printed. For the footprints, I took a picture of my Aurora’s footprints from the hospital and turned them into a grayscale alpha I could use it Zbrush. With it all done, it was off to the printer to be printed in Wood PLA, and a single piece in transparent so the glowing neopixels would show through.
The electronics were pretty basic on this, and you’ll find the code below. Done in circuit python, the neopixels glow yellow and pulse in brightness for a bit of effect. I also added some copper tape and a wire to use as a touch sensor so when you petted the back of the giraffe’s neck, the circuit playground express would play an audio file of my Aurora babbling. All in all, a bit of a tacky but heartfel little 3d printing + electronics project.
Trying to get back to doing more 3d modeling and renders, I made a quick scene of AirPods working on lighting and learning how to use MeshFusion in MODO. Took a little work to get my head around the basics of MeshFusion, but once I did, it was awesome.
Another 3d printing project done. I recently got a Nintendo Switch and my wife and I have been having a great time with Mario Kart 8. I wanted to create something that got the wheels for the game out of a drawer, but also looked fun sitting out. What better way of doing that then having the wheels sit in the most icon and painful item in the game series: the blue shell!
The creation process was pretty straightforward. I decided to just build the shell without worrying about real world dimensions, and then I’d scale it when I was ready to cut out the slots for the wheels. The model started with a base mesh in MODO which then got sent to Zbrush to finalize the form and add details like the gaps between the shell plates. With the main form done, it was just a matter of measuring the controllers, building out the shape in Shapr3D so it was to real world scale, and then bringing that into Zbrush to boolean out the cuts. When I was ready to print, I brought in both the blue shell and the cutouts I made in Shapr3D and scaled the blue shell to fit those, so I’d know I had the real world scale correct. Because of some problems with my printer, I printed it in 2 pieces that were glued together before painting.
If you like it and want one of your own, you can find the model over at https://www.thingiverse.com/thing:2839033.
In the never ending quest of trying to keep my office neat and organized, one of those items that seems to never really have a home is my laptop when it’s not in use, so it tends to get either stacked on top of something, or it’s the bottom of the pile. Either way, it tends to just cause a mess.
While there are a number of commercial solutions out there, I found this awesome model online: https://www.thingiverse.com/thing:2733609. It’s small, doesn’t take a ton of filament, and printed pretty quickly in just a couple hours on decent settings. To finish it off, I took some stick on felt circle and stuck them on the bottom so it sat nicely on my desk. Awesome model and now my laptop is standing vertically and out of the way.
This was one of those projects that came about not because I really wanted to do it, but because I had some hardware lying around that was needing a project to put it to use.
With my Adabox 006 from Adafruit, I got my hands on a Circuit Playground Express, which along with just an all around fun device to play with, gave me my first set of Neopixels to play with. Combined with some transparent filament I got for Christmas, I definitely wanted to do something that glowed. I kicked around a bunch of different ideas, but definitely due to the circular arrangement of the Neopixels on the board, decided to try my hand at making an arc reactor out of it which at it’s core is really just a 3d printed housing for the Circuit Playground Express.
The design was all done in Shapr3D on my iPad, with some measurements of the Circuit Playground Express and using some references pictures from the internet. I went with the Mark I variant of the arc reactor. It’s just cool and grungy and I figured that grungy effect would be easier to paint and pull off than something clean and polished. Definitely more forgiving. Here’s what it looked like within Shapr3D. With the design done, it was just a matter of cutting up the model and getting it ready to print.
3D printing on this was pretty straightforward. Most of the pieces required some sort of supports, but they weren’t too bad to deal with. I printed it in probably more pieces than were necessary, but it made it easier to paint when it was all done, and allowed me to spread the printing time more easily across a couple days instead of trying to do one big print session.
Once it was all printed, it was onto the usual process of sanding the pieces to get a nice finish, covering them in XTC-3D, and the sanding once again, just to get as smooth a finish as possible to start with. Once the surface was as good as it was going to get, it was onto painting. Each piece started with primer and a base coat of spray paint, with details being hand painted with a combination of some basics acrylic paints and some silver rub & buff which is just magic if you want to do any 3d printed pieces that look metallic. After several coats, I finished it off with some polyurethane to seal in the paint.
After that was assembly. Most of the pieces are just glued together. The exception to that was the top transparent section to the rest of it because I’m just not committed enough to this project to glue in my Circuit Playground Express permanently (I used tape and command strips) and some artisan copper wire for the “wire” parts of the build.
The final step was getting the Circuit Playground Express to glow when plugged in. While you can use python to program the board, I instead opted for trying out MakeCode from Adafruit when you can program the board using drag and drop blocks, which worked well for this project. Check out the completed project below:
Earlier this year in a previous post I outlined a fun little project I did to help alert my wife and I when the dog needs to go outside, using a couple Adafruit Feather Huzzah boards, some components, and a small laravel site. Since then I’ve simplified the project a ton replacing the “receiver” board which would play a sound by instead having the process call a cell phone to alert us using a mixture of Adafruit IO and IFTTT. It halves the amount of hardware needed and eliminates the need for spinning up a small laravel website as well. With it being more manageable, I figured it’d be a great time to open source this project as well. Keep reading to see how this project is made and how you make it yourself.
The goal of the product again was that when my dog rang her bells attached to the back door to go outside, my wife and I would get an alert about it. We were having problems with hearing her using the bell at night. So in this version, the dog bumps the bells with her nose, a sensor is attached to the bells which connects to Adafruit IO to record this, and we’ll use an IFTTT integration with Adafruit IO to call my cellphone to let me know the dog wants out. While I made this to monitor my dog needing to go out, it could be easily adapted to any soft of sensor triggering a phone call. Let’s get started.
Here’s a list of the materials used in creating this. While you could get this from a number of different places, I got all of this from https://www.adafruit.com.
The electronics setup on this is actually pretty easy because the Wifi connectivity we’ll be using is integrated into the Feather Huzzah. Really, we just need to connect the LIS3DH accelerometer to the Feather using some wires. Check out both the Fritzing diagram below, as well as the photo of my soldered together board. While you could do this on a standard breadboard, it’ll work better having it all soldered together, especially since it’s going to get bumped around and we don’t want any wires coming loose.
With mine, I needed to solder the headers onto the LIS3DH before I soldered it to the perma-proto board. If you need help with this, check out this awesome tutorial at https://learn.adafruit.com/adafruit-lis3dh-triple-axis-accelerometer-breakout/assembly.
The backbone of this project is going to be running on https://io.adafruit.com which is a sort of general REST api. Previously I had this running on a custom laravel site, but by using Adafruit IO, it’s one less thing I need the maintain, and one less thing for someone else to setup. We’ll have our Feather Huzzah communicate with Adafruit IO to record when the dog bumps the accelerometer. Head over to https://io.adafruit.com and create a new free account.
Once you’ve got an account, the first thing you’ll need to do is create a new feed to hold our data. Think of a feed as just a container for data. You can supply it a value and it’ll store it for a given time (it can do more, but that’s what we’ll be using it for here). Click on the Feeds link, and then go to Actions > Create a new Feed. In the modal window that pops up, give it the name “Dog Sensor” and hit the create button. It really doesn’t matter what the name of the feed is, but that’s the name I’ll be using here and in the sample code.
Dashboards within Adafruit IO are ways to visualize the data from feeds, or interact with it. While not required to make this project work, we’ll use this to help visualize that the sensor is actually working correctly. Click on the Dashboards link and go to Actions > Create a new Dashboard. Give it the name “Dog Sensor”, and then click on your newly created Dashboard, and you should be presented with a pretty unimpressive back screen. In the buttons in the upper right, select the plus icon to add a new “block” to your dashboard.
There’s a lot of these little block widgets you can add to your dashboard, but we’ll just be using the Stream block (the thumbnail looks like green text). Click on the icon. Next, you’ll choose which feed to use as the data for that block. Check the box next to the Feed we just created and hit the Next Step button. The final step in setting up the presentation of the widget. You should be able to leave the defaults as they are and hit the Create block button. That’s it! You’ve now got a little place to store your data and display it when the dog bumps into the sensor.
So far we’ve got this setup so that the data will be stored and we could view it if we wanted, but that doesn’t really get us to a phone call. So to do that, we’ll be using IFTTT to bridge the gap between Adafruit IO and the phone. Start by heading over to https://ifttt.com and create a new free account. Once you’re signed up, start by making a New Applet. You’ll be presented with a screen like that below. Click on the blue THIS text.
From here’s you’ll choose the service we want to integrate with, and really, what’s going to kick off this process. Find the Adafruit service and click on it. Next, click on the block for Monitoring a feed.
Next you’ll be presented with a simple form to connect to the Feed you created in Adafruit IO. Select that feed, set the relationship to Equal To, and the Value to 1, and then hit the Create Action button. Next, we’ll need to set what happens when our Feed gets a value of 1. On the next screen, click the big blue THEN text to choose an action. Choose the Phone Call service (if you wanted, you could also have it send a text message!). In the options for this action, you can specify text that will be spoken when you answer the phone. Since my dog’s name is Kona, I set the text as “Kona needs to go outside!”. Make it whatever you want, and create the action. That’s it! When Adafruit records a new datapoint in that dog sensor feed that equals 1, you should get a phone call.
An important piece to note is that you might see a delay between that data being recorded and the phone call occurring because you’re at the mercy of how often IFTTT polls Adafruit for you. I’ve found the delay is typically anywhere between 4 and 15 seconds so if this is something that requires immediate response, IFTTT might not be the best option for you.
So far the hardware is done and our cloud related integration is done, but we’ve yet to get any code on our board to make the whole thing work. Since the Feather Huzzah supports it, I decided to do this project using Circuit Python instead of the normal Arduino code + IDE as a way to test out the process, which has been pretty slick. However, there is a bit of a setup to get this to work and get Circuit Python flashed onto the board. If this was using one of the cool M0 boards like the new Trinket M0 from Adafruit we wouldn’t have to do this as they come with Circuit Python already loaded (plus you can view the files like an external drive), but with this Feather Huzzah that’s not the case. So the first step will be flashing the Feather Huzzah to use Circuit Python. There’s already a pretty good guide over at https://learn.adafruit.com/micropython-basics-how-to-load-micropython-on-a-board?view=all#esp8266 that you should follow. The directions are for Micropython but work fine for Circuit Python (in fact, Circuit Python is a fork off of Micropython). Basically you’ll be using a command line tool called esptool to do the actually flashing of the board. Once you’ve got the board flashed, let’s proceed onto installing Ampy.
Now ampy is the command line tool that’s used to interact with the python files and folders on the board. You’ll edit these on your computer, and then “push” them over to the board itself. This article on Adafruit has a great walkthrough on installing Ampy on your computer: https://learn.adafruit.com/micropython-basics-load-files-and-run-code/install-ampy. Once you’ve got ampy installed, you’ll need to download the project code and libraries we’ll need as well.
Start by downloading the following code / libraries:
Next, let’s load the libraries we need onto the board first. We’ll do that using the ampy tool that was installed earlier. We’re not going to need all of these libraries, but just a few within these packages. Let’s start by adding the umqtt library which is found inside the micropython-lib library within the umqtt.simple folder. Use the following command, but you’ll need to make sure you update the path to the library, as well as the appropriate port for your board:
ampy --port /dev/tty.SLABUART put micropython-lib/umqtt.simple/umqtt /
Next, we’ll do the same thing to add the bus_device and LIS3DH libraries:
ampy --port /dev/tty.SLABUART put Adafruit_CircuitPython_LIS3DH-master/adafruit_lis3dh / ampy --port /dev/tty.SLABUART put Adafruit_CircuitPython_BusDevice-master/adafruit_bus_device /
Cool, now you should have all the libraries we need on the board. Next, we just need to modify the main dog sensor code before loading it on the board. Go ahead and open circuit-dog-sensor/main.py in the text editor of your choosing. If you scroll to the bottom of the file, you’ll see a number of variables declared that you’ll need to update. Start by updating the wifi_ssid and wifi_password with the name and password of your WIFI network your Feather Huzzah will be connecting to. Next, update adafruit_username with your Adafruit IO username, and adafruit__aio_key with your AIO key. Finally, update adafruit_feed_key with the key / name of the Feed you created on Adafruit IO. Mine was named dog-sensor. With that updated, run the following command to add this file to your board. Circuit python will automatically run the file named main.py when the board gets power.
ampy --port /dev/tty.SLABUART put circuit-dog-sensor-master/main.py /main.py
You should be good to plug in your board and give it a test. When powering on, it waits 30 seconds before attempting to read a “bump” so you don’t set it off right away. Wait 30 seconds, and then give it a nudge. If it all works, you should see the data point created in your AdafruitIO dashboard and receive a phone call! To make it a little more obvious for me when the call was coming in from the sensor, I went ahead and made a new contact on my phone and just called it “Dog Sensor” so I don’t have to actually answer the call to figure out what’s going on.
If you’re having trouble, you can plug your Feather Huzzah into your computer and use the screen /dev/tty.port_name_here 115200 to read debugging messages from the code. Enjoy and check back for more tutorials!
After watching the latest Star Wars trailers, I was so excited for the upcoming movie. Not just for the lightsabers and battles and the force, but the smallest character in the trailer — Porg! While he might’ve only had a couple seconds of airtime, I’ve got high hopes for this adorable little creature and wanted to make one of my own.
I spent the night modeling my own little Porg using Zbrush, and then decimated the poly count so it’ll be a little easier to print. With my model done, it was time to export and print.
The total printing time for this project was about 14 hours. Would’ve been worse but for a model about 5″ tall it really wasn’t that bad. I was able to print it with a wall thickness of 4 and 0% infill so it was completely hollow the entire way through. While taking less time and less material to make, it also make the model incredibly light.
While it was supposed to be printed in one piece, I had a bit of a problem where my print failed partway through due to some supports falling down. Rather than scrap the parts that already make it through, I just printed the rest of the model and figured I’d glue it later. Good thinking too as a couple more layers ended up separating when pulling it off of the build plate. Guess next time I’ll be more careful in doing that.
Bit of a bummer, I think it would’ve looked better in the end if it wasn’t for that. Oh well. Some light sanding on the glue points to make sure the glue stuck well, and then glued it all together (result below). Not too bad though you can definitely see the seams where the pieces were glued, as well as some printing gaps. Not sure exactly what was up with that though I believe it was a z-axis alignment issue as it only started showing up in the top part of the model.
Once it was all glued together, it was onto the finishing process. Nothing special here — start with some sanding to smooth out layers, especially the joins between the glued pieces. Start with a gritty paper and work your way up. Once I was happy with that, I painted on a coat of XTC-3D, let it cure, and then sanded it some more. With a nicer surface to work with, the final step before painting was hitting it with a coat of sand-able primer.
With the surface ready for painting, it was just a matter of starting with the base colors and progressively adding in more details and variation. Over a couple nights it took maybe a couple hours of hand painting with just acrylic paint you’d find in any hobby store. Once I had the paint where I wanted it, or at least to the point where I didn’t think it was going to get any better, I finished it off with a coat of sprayable polyurethane to help seal in the paint. Check out the final model below. If you like it and want to make your own, you can find the STL file at https://www.thingiverse.com/thing:2593522.
I picked out this fun gray pumpkin at the pumpkin patch. But what to do with it? Why not turn it into a green glowing alien, with a little Arduino power. The design was pretty simple, just a small round alien head with big eyes, carved out like a normal pumpkin. Here’s a video of the overall effect.
With the pumpkin carved, I thought it’d be a cool effect to have it glowing green. I had an extra Arduino board lying around and a big green LED that was wanting to be used. Why not? The Arduino setup was way easier than actually carving the pumpkin. All it does it every second link the green LED on and off, using the example Arduino sketch appropriately called Blink. You can find it as well as a schematic here: https://www.arduino.cc/en/Tutorial/Blink (I didn’t create this, just borrowed it).
With that working, I hooked it up to a battery pack, and stuffed it in the pumpkin. The only bummer was that the Arduino was pretty visible, and the light didn’t really fill the pumpkin. My wife came up with the great idea of cutting a bit of white garbage bag and pinning it just inside of the front of the pumpkin to help diffuse the light. Looked a little wonky in daylight but at night it was awesome!