Monoprice Mini 3D Printer Unboxing and First Prints

So, I decided to jump on the increasingly large Monoprice bandwagon and get one of the amazing $200 printers.

First, I had to calibrate the bed height as instructed. The manual said that a sheet of A4 paper, which should be 0.05mm thick, would be able to slip in between the hotend nozzle and the bed when it was calibrated properly. I was planning on using a normal sheet of printer paper for this, but after breaking out the digital calipers I discovered that the printer paper I own is around .1mm thick.

This seemed like it was going to turn into some wild goose chase for .05mm thick paper, but I discovered that some college ruled paper that I had lying around would do the trick. The process of adjusting the bed height was very simple, as I only needed to rotate the screws a quarter turn before it was at the right height.

So then, it was off to printing. It works remarkably well with Cura – I had no issues, and it produced great prints.

I’m honestly surprised at the quality of the prints and the fact that nothing went horribly wrong right away. I read reviews about the printer and everyone seemed to agree that it was remarkable, but that it had some glaring issues, like a quick-to-fail power brick or a PID tuning problem with the hotend temperature. It seems like Monoprice has fixed those two problems, at least, because the power brick hasn’t failed (yet) and the hotend temperature seems to hold steady during prints.

Of course, I had to make a mistake somewhere, so I accidentally jammed the remnants of the sample white filament while trying to load some black Hatchbox filament. While fixing the problem, I got to take a closer look at the hotend – the Bowden tube is really only held on by pressure from one screw.


Of all the reviews I looked at, I found Hackaday’s and John Biehler’s the most useful.

All in all, I’m satisfied with the printer, and I’m excited to start printing some cool models!

Tutorial: Using ESP-IDF to flash the ESP32 Thing

Victory! I’ve managed to upload code onto the Sparkfun ESP32 Thing using ESP-IDF. This means that (hopefully) I will be able to make full use of the chip’s capabilities, including (dare I say it?) BLE.


For now, I’ll stick with “Hello world!” and LED blinking, though. The Thing has a lovely blue LED on pin 5 that is very useful for testing code and, coincidentally, Espressif provides a Blink example. Perfect!

The process of uploading the code to the ESP32 was a bit difficult for me, either because of a lack of experience or because it is actually difficult. In any case, I wanted to describe the steps I took to flash the ESP32 in case anyone else is having trouble with it.

1. Make sure ESP-IDF is set up.

Make sure that ESP-IDF is set up properly according to the steps on Espressif’s Github page. You don’t need to have Eclipse set up for this – all you need is the msys2 environment and the SDK.

2. Open msys2 and set it up.

Open up the msys2 command shell that came with the ESP-IDF installation (should be found at C:\msys32). First, we need to set the environment variable for the location of the IDF folder. Use this command:

export IDF_PATH="C:/path/to/IDF/folder/esp-idf"

There’s a way to make this run every time msys2 opens, but I haven’t figured it out yet. Next, use cd to move to the directory where your project is (not the IDF folder). For this example, I’m using Espressif’s Blink example project, with a “Hello world!” added in.

3. Configure the project.

Next, use this command:

make menuconfig

This will open a configuration screen that looks like this:


You can change a lot of stuff in here, but we only need to change one thing: the serial port. Navigate to Serial flasher config -> Default serial port. It will be set to /dev/ttyusb0/ or something like that – whatever it is, it doesn’t work. Delete that setting and enter the correct COM port. My ESP32 Thing showed up on COM3.


Press Ok and exit the config using [ESC] [ESC].

4. Building and flashing.

Use make to build the project. The first time you do this, it will take a while. Next, plug in the ESP32 Thing and put it into bootloading mode (press button 0 and then reset, then unpress reset and then unpress button 0). Use this command to start the flashing process:

make app-flash

Do not use make flash – this tells the IDF to flash the bootloader, partition table, and application. Since we already have so much on board with the ESP32 Thing, all we need to flash is the app; this is what make app-flash does.

If everything works, this is what you’ll see:


And just like that, we have blinking LEDs!

Since I added a “Hello world!” to the code, the ESP32 also says hello with every LED blink. To view any data that is being logged, use make monitor to create a nice serial output window.

This is a fairly unimpressive test of the ESP32, but hey, one step at a time. Next, I’ll be experimenting with connecting to wifi, hosting a wifi server, and maybe even BLE. Just maybe.

That’s all for now!

Working with the ESP32

I recently bought a Sparkfun ESP32 Thing, and I’m excited. I think the ESP8266 is really cool, so its big brother is a must have. Wifi and BLE in one chip? Awesome.

Only one problem – the Arduino library for the ESp32 doesn’t include functionality for BLE (including several other functions, like analog read and write). This was disappointing for me because without BLE, the ESP32 seems just like the ESP8266 with a few more GPIO pins. So I made a big decision: I would use Espressif’s IoT Development Framework (ESP-IDF) instead of Arduino IDE.

In short: Compared to Arduino IDE, it’s a dark and scary world out there.

I shouldn’t be too dramatic, though. Following Espressif’s setup instructions is straightforward enough and actually seems to work. Kudos to them for putting together all of this. Their Github page is also really useful. However, they use a command-line environment to build and flash the code for the ESP32. I love a good command line, but it just isn’t as familiar as an IDE.

We’re gonna need a bigger window.

So I tried setting up something friendlier, like Eclipse, but it doesn’t seem to work 100%. I managed to work through the difficulty of adding the various include paths, etc., but Eclipse still won’t let me flash the chip. So I’ll be using the command line until further notice – plus, I’m starting to get used to it.

I mentioned earlier that I’m using an ESP32 Thing. I think that this setup is probably a bit different from what Espressif was imagining when they designed their IDF, since the Thing has so much extra hardware that makes it easier to use. However, I think I’m getting the hang of uploading code to the ESP32 – I’ll make a tutorial for that soon, in case other people are having trouble with it.

That’s all for now!

Welcome to my blog!


This is my blog about DIY projects that I do. I’m a maker who works on DIY projects as a hobby. I did my first projects using Arduino, but I work with other platforms too. Sometimes, I just do straight up coding – I like HTML and Javascript the best, but I’ve also worked with, C++, Python, and PHP.

I have a few projects in the works that I’ll be posting about soon, including one involving the new ESP32. Enjoy!