The ePulse Feather

The Color Kit Grande is the sum of many things Marcel and I learned in the last couple of years. We replaced the NodeMCU from the Classic Kit and the Wemos Mini from the Color Kit with our own ESP32 ePulse Feather. As the name indicates the ePulse Feather follows Adafruit’s Feather specification. The ePulse Feather is also very efficient when it comes power consumption: it only consumes down to 12uA when in deep sleep! A true IoT dev board should be powered by batteries and the ePulse Feather allows this with a LiPo charger and connector. And it uses the powerful ESP32 microcontroller which is a big upgrade compared to the ESP8266. More RAM, more flash, more cores, more possibilities!

The Display Module

But not only the microcontroller board got better compared the the older Color Kit. We also added a better display module. It communicates over SPI with the ePulse Feather to change the pixels on the display. The added PSRAM memory of the ePulse Feather allows us to write better looking programs with more colors!

We also replaced the (ancient) resistive touch screen with a capacitive module. This is the same technology that you know from modern smartphones and tablets and is much more precise and intuitive to use.

The Connector Board

The ESP8266 Color Kit was the first of my kits to include a custom component and it required you to solder pin headers. The Color Kit Grande still has such a PCB which we call connector board. But this time we offer you various difficulties of soldering. There is a power switch with classic through hole soldering and a wide pin pitch with enough space for even a wide soldering tool.
The pin headers for the ePulse Feather are in 2.54mm pitch and are a bit more delicate but still not too hard for a beginner. We also added a Grove connector to connect to a wide range of sensors and actors using the same system. And the Grove connector is surface mounted which again is a bit more complicated to solder.

The Kit Box

Even with the kit box we learned from our older products: both the Classic Weather Station and the ESP8266 Color Kit came in a box which is 4cm high. This was sometimes problematic for shipping and added extra costs. The Color Kit Grande box is only 2cm high and everything fits neatly in it. The box even serves as a stand. How cool is that?

The New Weather App

Not only the hardware is new, we also rewrote the popular weather app from scratch. More memory and more CPU power means that we have more colors to play with. To make setup of the development environment as easy as possible we decided to use platformio and Visual Studio Code. While the Arduino IDE is very good for beginners it makes it hard to ensure that every maker has the same setup on his/her machine. With platformio we can define the exact versions of libraries you use. No conflicts because of old and outdated dependencies! Just do the required changes in the settings.h file and upload the firmware!

Where to buy

The Color Kit Grande is available at the ThingPulse web shop. As you might know, I founded ThingPulse together with Marcel back in 2018 to professionalize the distribution of the projects posted on this blog. Since then we developed many new products together which are also available in the shop.

Coupon: For the readers of my blog I have a special treat! Use the coupon code SQUIX-CKG to save USD $5 when buying a Color Kit Grande in the ThingPulse Shop. Valid until July 31, 2023

Links

• Color Kit Grande Shop Page
• Assembly and programming instructions
• Weather Station Touch on Github

For a long time, I had been planning to build ESP32-based devices to measure the temperature in my apartment. In summer, visualizing the temperature helps in ventilating the apartment efficiently, while in winter, it helps to keep an eye on the humidity levels. However, more important projects kept taking precedence, and I never really got around to building the sensor network. That is until I discovered the OpenMQTTGateway project.

What is the OpenMQTTGateway?

The OpenMQTTGateway is an open source project that may not seem like much, but it is incredibly effective. An ESP32 flashed with this firmware will scan for devices and read their values if possible. The gateway ESP32 will then publish the discovered devices to specific topics on a MQTT broker. If the firmware recognizes a device type and can communicate with it, it will also publish additional information.

The published information includes a plethora of data to play with, with each device having its own topic, and a JSON structure containing the collected information.

Hardware: The Gateway

To run OpenMQTTGateway, any ESP32 device can be used. However, to travel in style and maintain the aesthetics of my apartment, I opted for the ThingPulse ESPGateway, which comes with a sleek enclosure and an external antenna that helps to communicate over a longer distance. For those who want to connect the gateway over Ethernet, the Ethernet the ESPGateway is also a good choice.

Hardware: The Sensors

For the room sensors, I used Xiaomi BLE sensors that are very affordable and measure temperature and humidity, communicating over Bluetooth LE. When purchased in bundles, these sensors can be found for less than USD $5 on Aliexpress.

By using a custom firmware that can be flashed using this GitHub project, additional features can be added to the sensors.

Plant Sensors

Apart from the Xiaomi BLE Room sensors, there are many other devices that can communicate with the OpenMQTTGateway in my home. For instance, the Xiaomi Flora Plant sensors work exceptionally well to report soil humidity, temperature, and light.

Presence Detection

You can also use the OpenMQTTGateay to track the presence of devices in your apartment. For instance if you are wearing a Fit tracker like the Xiaomi Mi Band you can track the presence of the people wearing them.

Storing, Controlling and Visualizing

To store, control, and visualize the data, I have a Raspberry Pi 4 running the MQTT broker. A Node-Red instance takes the data and pushes it into an InfluxDB. Then, Grafana is used to visualize the data over time. And this is how it looks for the Xiaomi room sensors:

Step by Step Instructions

In EasyEDA:

1. Export the layers as DXF file, File > Export > DXF…

In Fusion 360:

1. In a new design create a new component and activate it.
2. Import the DXF file: Insert > Insert DXF. In the dialog choose One Sketch per Layer…
3. Create a new sketch on the same plane and call it PCB
4. Project (Shortcut ‘P’) all relevant and correct sketch features into the new sketch.
   • Some elements might be wrong, in that case, import enough to fix them (see video).
   • Remove the checkbox behind “projection link”. This allows you to change projected lines independent from the imported sketches
   • Make sure the PCB outline is closed (the PCB in the sketch is light blue)
5. Extrude (Shortcut ‘E’) the PCB downwards with the thickness you will order your PCBs with.
   • In my case, I entered -1.6mm.
   • The sketch plane should be on top of the PCB. This will make it easier to align the electronic components later
6. Create a new top-level component for every electronic part you wish to import.
   • You don’t need to import every capacitor, chip, or resistor. You can of course, but this will be very tedious.
   • Only import parts that interact with the enclosure: plugs, buttons, sensor or the parts with the biggest height

In EasyEDA:

1. Open the PCB view. Put your browser (e.g. Chrome) into inspect mode by right-clicking somewhere at the top of the browser window.
2. Open the tab to display network traffic (“Network” in Chrome).
3. In the PCB view select the component you want to export
4. In the right tab > Custom Properties > 3D Model click on the text field
   • This will force EasyEDA to download the 3D model of this component.
   • In the inspect mode window two new lines appeared.
5. Right-click on the last one and Choose “Open in new tab”.
   • This will download the 3d model into your download folder
6. Repeat this for every part you need in Fusion 360

In the File Explorer/Finder

1. Rename the file you just downloaded and add “.obj” as extension, e.g. “USB_C.obj”
2. Repeat this for every part

In Fusion 360:

1. Activate the component of the part you are going to import
2. Import the obj file: Insert > Insert Mesh
   • Rotate the object in the correct direction
   • Place the object somewhere above its final location on the PCB
3. If needed, repair the mesh: Mesh > Prepare > Repair…
4. Convert the Mesh: Modify > Convert Mesh…
5. Place the part: In the Solid workspace > Modify > Align
   • Choose a feature on the part that you can also find on the PCB/ sketch
   • Use Flip/Angle to rotate the part until it fits
   • Sometimes you need several Align operations: e.g. first align x-axis and y-axis, then use another feature to align z-axis
6. Repeat with all parts/ components

Congratulations, you have successfully recreated the PCB and it’s most important components in Fusion 360. Now you can use this model to create your enclosure. But this is content for another post;-)

Video

Here is the code used to create the signals

#include <Arduino.h>

uint8_t pins [] = {21, 19, 18, 5, 4, 34, 25, 26};

void setup() {
  Serial.begin(115200);
  for (uint8_t i = 0; i < 7; i++) {
    pinMode(pins[i], OUTPUT);
  }
}

void loop() {
  for (uint8_t pin = 0; pin <= 7; pin++) {
    digitalWrite(pins[pin], HIGH);
    delay(50);
    digitalWrite(pins[pin], LOW);
    delay(50);
  }
  delay(500);
}

And this is the recorded output:

There is one step missing. The area for this is marked. This behavior can be easily explained because GPIO35 (element 5 in the array) is a input-only pin. Therefore no state can be written to it by my program.

Links

Link to LHT00SU1 Logic Analyzer on Banggood (~35USD):
https://www.banggood.com/custlink/DmmY0l4fpW

Link to SigRok/ PulseView Open Source Software:
https://sigrok.org/wiki/Downloads

For the latest version of the LilyGO TTGO T-Camera ESP32 the manufacturer made a couple of significant changes. The switched the ESP32-WROVER module with the ESP32 chip, flash and PSRAM are also separately soldered and the module got a “3D antenna”. But I had to deal with a bigger problem at first. LilyGO also replaced the CP2102 chip with the WCH CH9102 UART chip. My Mac OS X 11.5.2 Big Sur installation recognized the chip immediately as

crw-rw-rw-  1 root  wheel   22,  14 Aug 29 08:24 /dev/tty.usbmodemXXXXXXXXXX
crw-rw-rw-  1 root  wheel   22,  15 Aug 29 08:24 /dev/cu.usbmodemXXXXXXXXXX

I changed the lines in my platformio.ini file and used the cu.usbmodemXXXXXXXXXX (actual numbers replaced with XXX). Monitoring seemed to work since I could see the output from the stock firmware.

But every time I tried to flash the chip I got the following output:

Connecting....
Chip is ESP32-D0WD (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
Crystal is 40MHz
MAC: 3c:71:bf:xx:xx:xx
Uploading stub...

A fatal error occurred: Failed to write to target RAM (result was 01070000)

I first suspected that the esptool needed adaptation for the new chip. There were also a couple of issues on github in the esptool repository: https://github.com/espressif/esptool/issues/280

The Solution

Or might the driver be the problem? The website of the CP2102 manufacturer also did not show a new driver for the chip. After more digging, I finally came across this github issue and genotix’ post: https://github.com/Xinyuan-LilyGO/LilyGo-T-Call-SIM800/issues/139#issuecomment-904390716

Genotix links a zip file containing a driver aptly named CH34xVCPDriver_signed.pkg The CH34x driver seems also to work for the CH9102 chip. Now you have to be brave and install the driver by ignoring all Max OS X security warnings and by clicking through installation dialogs in Chinese.

After the installation two new serial devices showed up:

crw-rw-rw-  1 root  wheel   22,  12 Aug 29 08:24 /dev/tty.wchusbseriaXXXX
crw-rw-rw-  1 root  wheel   22,  14 Aug 29 08:24 /dev/tty.usbmodemXXXX
crw-rw-rw-  1 root  wheel   22,  15 Aug 29 08:24 /dev/cu.usbmodemXXXX
crw-rw-rw-  1 root  wheel   22,  13 Aug 29 08:34 /dev/cu.wchusbserialXXXX<--correct

By using the cu.wchusberialXXXX I finally could program the T-Camera module.

Voice assistants and smart home applications go together really well. For several years now we have an Echo Dot with Alexa running at home and I have connected more and more devices to it. Another important factor in my smart home setup is a Node-Red instance running in a docker container on a RaspberryPi 4.

Why Running Node-Red in Docker?

I probably could save myself some trouble if I would just install Node-Red as regular service on the base system on my Raspberry Pi. Especially where Node-Red needs direct access to RPi hardware resources. It took me quite some time to figure out how I can use the RPi Bluetooth device from within the docker container. In a nutshell: you have to use network_mode: host to share the BLE hardware between host and container.

But I believe that the benefits of running such applications like Node-Red in a docker container outweigh the trouble. Updating or trying out different configurations is super easy. And all the resources are cleanly separated from other containers running on the same machine.

The Alexa-Home Node

I have a couple of Tasmota powered Shelly devices, allowing me to control lights either with a regular light switch over WiFi. You can set up Tasmota devices to be discoverable by Alexa. Then with a simple “Alexa, turn on the corridor” you can control the lights in your corridor. But what if you want to make a new command accessible to Alexa that is not represented by a physical device?

This is where the Alexa-Home node comes in. The official name is node-red-contrib-alexa-home and this extension comes with two nodes: a controller and a device node. The controller lets you do some basic settings like the network port used for discovery while the device node lets you setup a virtual device.

So for instance I created a node called “Everything” and now I can turn off all lights by calling “Alexa, turn off Everything”. Nice, eh? But sadly this didn’t work right away. Once more I suspected the docker setup and I was correct.

The Solution

No matter what I tried, the virtual devices from Node-Red did not show up in Alexa’s device list. So I assumed some kind of networking issue. According to this github project the device needs to listen on a certain port, for generation 3 devices this has to be port 80. Alexa must be able to download the file /alexa-home/setup.xml from the RPi. This file contains the device description.

That means we have to make sure that a request to the RPi is forwarded to our Node-Red container. Now the next steps depends on your setup. I’m running Node-Red together with MQTT from a docker-compose command. And as mentioned earlier this setup is using “network_mode: host”:

Setting network_mode to host allows the container to share the same network namespace as the host OS. When this is set, any ports exposed on the container will be exposed locally on the device. This is necessary for features such as bluetooth.

Source: https://www.balena.io/docs/learn/develop/multicontainer/

This means that I cannot do port mapping in the docker-compose file because host-mode together with port-mapping is not allowed. That means that the port which uses Alexa-Home to publish it’s setup.xml must be exposed from the Dockerfile.

I set my Alexa-Home controller node to port 80:

And in the Dockerfile I added

EXPOSE 80

And that’s it! Rebuild the docker container and restart both containers with docker-compose. Now add an Alexa-Home node in your Node-Red web interface and set the device name in the node configuration. This is the name you will use to give commands for that virtual device. Then tell Alexa to “Discover devices”. After about 20 seconds she will tell you that she discovered your new device.

Now you can create nodes just like this one:

Summary

Alexa and Node-Red can be a powerful team. You can create powerful commands in Node-Red which Alexa can understand. While you are limited to simple commands like “Turn On XXX” or “Dim XXX to 50%” you can get a long way with this.

Running Node-Red in a container is a powerful thing and has many benefits. But it also complicates things every once in a while. And connecting Alexa and Node-Red over the device discovery is such a thing. But if you are in this situation you’ll hopefully find this blog post and have it up and running in no time!

I have connected devices to TheThingsNetwork before but with this device I had several challenges: no useful example project, TTN just switched to the new V3 version and bad documentation about the hardware. After the first failure I assumed that the TTGO-LoRa32 was to weak to send data to the next gateway. Since my own TTN indoor gateway was still registered for V2 I started to migrate it first. That was another bad experience. The gateway did not connect to TTN V3 and I reclaimed it several times without success. Only after waiting one night it finally worked and I had a gateway connected to TTN v3.

So now that I knew that I had a gateway close enough to receive the TTGO-LoRa32′ data package I could concentrate on fixing the code.

Prepare the Code

In this project, I’m using platformio in Visual Studio Code for editing and uploading the firmware. As a first step get the code from my github repository https://github.com/squix78/TTGO-LoRa32-V1.0-TTN-OTAA either by cloning it with git or by downloading the code as zip file and extracting it.

This project should work as it is except for a few changes we have to do in the code. The most obscure change is buried deep in the library folder in a file called lmic_project_config.h. The full path to the file is
.pio/libdeps/ttgo-lora32-v1/MCCI LoRaWAN LMIC library/project_config/lmic_project_config.h
If you can’t find this file you probably have to compile the project first, since only then all the dependencies will be downloaded. Please note: at the moment the compilation will fail, since we didn’t set the credentials in the code yet. This is expected and normal.

Once you find that file make sure that the correct region settings are there. For Europe 868MHz band it should like this:

// project-specific definitions
#define CFG_eu868 1
//#define CFG_us915 1
//#define CFG_au915 1
//#define CFG_as923 1
// #define LMIC_COUNTRY_CODE LMIC_COUNTRY_CODE_JP	/* for as923-JP */
//#define CFG_kr920 1
//#define CFG_in866 1
#define CFG_sx1276_radio 1
//#define LMIC_USE_INTERRUPTS

By default the code uses CFG_us915. If you are living in another region it is very important you do that change!

Getting the app and device credentials

This was the first device I set up for TTN V3 and there are a couple of traps I want to point out to you. A quick explanation for the TTN novice: Your device needs three credentials to connect to TTN: AppEUI, DevEUI and AppKey. In TTNs V2 interface you could either provide the DevEUI or it would create them for you. In TTN V3 this auto EUI generation is currently missing. For many devices the vendor will provide these identifiers and you just have to enter them in the TTN console. But with devices such as the TTGO-LoRa32 you don’t get it. I show you here how to create it by yourself. This is not ideal but works… Just don’t blame me in case of problems…

1. Head over to https://console.cloud.thethings.network/ and pick your V3 region. Don’t use the V2!
2. Create an account if you don’t have one yet.
3. Go to applications and create a new application. As application id you can pick anything as long as
   1. it doesn’t exist yet
   2. only contains letters, dashes and numbers
4. On the next screen click on “Add end device” (see image below)

5. Now go the “Manually” tab and choose “Over the air activation (OTAA)” and MAC V1.0.2
6. On the next screen choose a name for your device consisting only of letters, numbers and dashes. To fill in the JoinEUI and DevEUI you can use this generator: https://descartes.co.uk/CreateEUIKey.html
7. On the next screen choose your region and the following settings:

8. On the Join settings screen you can click on the “recycle” symbol to generate an AppKey for you.
9. Now we have to copy the credentials over to our code. We have to provide JoinEUI and DevEUI in least significat byte order or short LSB. The TTN console helps you with that. First click on the “<>” icon and then on the arrows beside “msb”. To put the data into the clipboard use the most right icon. BTW: The name of JoinEUI is AppEUI in the code. Please add the AppKey msb order, no need to invert the order there.

10. After copying JoinEUI (AppEUI), DevEUI and AppKey to the main.cpp file in the code you got from github you can compile and upload the firmware to the TTGO-LoRa32
11. Now check if it worked by looking at the device live data on the TTN console:

Summary & Outlook

This is it! If everything worked you your TTGO-LoRa32 is now sending messages to TTN V3, joining it with dynamic session keys! If I find the time I’d like to analyze the power consumption of the device for sending a message as well as in the sleep phase.

My code is not using the OLED display. There is a repository provided by LillyGo that shows you how to do that: https://github.com/LilyGO/TTGO-LORA32/tree/LilyGO-868-V1.0

If you like to support my blog please consider buying the device by using this affiliate link: https://www.banggood.com/custlink/vmDdBjpESq

The ESP32 platform offers a wide range of functionality almost out of the box. For instance you can turn a ESP32 with little effort into a Bluetooth Audio speaker. In this article I describing how I tapped into the digital data stream coming from a smartphone to visualize the music with a 8 band VU meter. The code is also a nice example how to you can use the full power of the two Tensilica Xtensa cores in the ESP32.

The ESP32 is an amazing piece of hardware. It is very affordable, easy to use and comes with great libraries. One of those is the esp32-a2dp library by fellow Swiss Phil Schatzmann. With this library you can turn any ESP32 into a bluetooth sink or source. Using it as a sink effectively turns it into a Bluetooth speaker, using it as a source you can send music to a Bluetooth speaker.

Depending on your hardware, this is the minimal code to use the ESP32 as a bluetooth speaker, announcing its services as “MyMusic”:

#include "BluetoothA2DPSink.h"

BluetoothA2DPSink a2dp_sink;

void setup() {
    a2dp_sink.start("MyMusic");
}

void loop() {
}

Wouldn’t it be nice to visualize the music you receive over Bluetooth? I always loved the spectrum analyzers which split the available frequency spectrum in several bands and displayed the intensity in those bands. In August 2019 I wrote a post about how to do that in the browser with sound recorded on the ESP32.

Eavesdropping

Is it possible to get access the digital data stream received over Bluetooth? The A2DP library has a hook to register on events like “stream started” or “stream paused”. But there is no callback to tap into the audio data.

The library is actually a conveniency wrapper around the A2DP functionality in Espressif’s Audio Development Framework (ADF). It uses the esp_a2d_sink_register_data_callback(..) method to get the Bluetooth data stream.

By registering my own callback I could “slip in” between ADF and the A2DP library! Now my method with the signature

void audio_data_callback(const uint8_t *data, uint32_t len)

will be called from time to time with a pointer to the current music data package.

Not Enough Horsepower!

A common method to visualize music is to take slices and convert those into the frequency domain. Blocks with a length of a couple of milliseconds will then show which frequencies are currently active. The process to convert data from the time domain into the frequency domain requires quite a lot of calculations. One algorithm which can do this relatively efficiently is the Fast Fourier Transformation or short FFT.

So just like in my previous project I wrote code which would collect music data until a buffer was full. Then the code would run the FFT algorithm to get the content of the buffer as an array of discrete frequencies. This worked, but the music started to sound awful! Apparently the FFT algorithm took too much time to process the data and the output would stutter.

If One Horse Can’t Do It…

…two can! The ESP32 has two Tensilica Xtensa cores. Until now I never really had a use case where I needed to use the other core. I was also under the impression that you should leave that core alone since all the WiFi processing and other system tasks run on it. But why not give it a shot and do the Fast Fourier processing on the other core?

The revised code fills the buffer as before on core 0. But once the buffer is full it stops collecting data and notifies a task running on core 1 that it can start running the FFT processing on the buffer. Once the FFT processing is completed the code clusters the frequency information into 8 bands.

At this time the task on core 1 will tell the other task on core 0 that it can start again to fill the buffer. Core 1 doesn’t need the data in the buffer anymore. Now core 1 only needs to visualize the intensity of the 8 bands.

Multicore Programming

The data collecting task and the FFT processing task have to communicate with each other. This has to happen thread-safe and if possible without blocking each other unnecessarily. I used a RTOS queue where the data collecting task places a message when the buffer is ready for processing. The FFT task on core 1 starts once it detects a message in the queue. When the buffer is ready for more data it removes the message from the queue.

I have to admit that I’m not sure if my solution is the correct or best way to solve this problem in RTOS. I tried with semaphores but always ended up that all tasks were blocked. Please let me know in the comments below how you would have implemented this.

Hardware

The code I wrote should theoretically run with all DACs supported by the esp32-a2dp library with minor changes, even the internal ESP32 DAC. I wrote the code as a stock firmware for the ThingPulse Icon64 device. You can see it in action in the video below.

Get the Code

I published the code for this project on Github. I hope you can profit from it! As I mentioned before, if you have suggestions how to improve the multi-tasking code or other aspects please let me know either in the comments below or on github!

When we designed the ThingPulse ePulse board I knew I wanted to have a Fritzing part to document new projects with it. I had already designed parts for Fritzing before, but it was very consuming: you start with a similar component available in Fritzing and then modify it until it looks and behave the way you want it.

But there is an easier way. If you want to create a Fritzing Part for a component you design in Eagle CAD you can use a tool to do most of the conversion for you. It took me hours to compile that tool and work around some issues. The tools was original written by the Fritzing team, then improved by Adafruit. But it just wouldn’t compile on my Mac.

So I fixed some of the issues, simplified the setup and documented everything in the README file of the github repository.

I hope this saves you a lot of time and creates lots of new parts!

A while back I got a cheap Chinese 3018 CNC desktop mill (link to banggood). It can mill wood, acrylic and many other softer materials. Some people even used it to engrave aluminum.

You can buy these devices in many different versions and sizes. They are usually built with 2020 and 2040 extrusion elements and 3D printed parts. 3 stepper motors control the position of the tool. One for the table in the Y-direction. And two stepper motors move the tool in X and Z direction. Mine is called 3018 in reference to the size of the build table: 30x18cm.

A spindle motor rotates the tool bit to engrave or cut away from the base material. With many of these CNC machines, you can replace the spindle motor with a (weak) laser module for engraving or cutting. I extended mine with a 2.5W laser (buy here) and it is strong enough to cut cardboard or even thin balsa wood. Turning the CNC machine into a laser cutter is quite easy. The controller board of my machine has a plug for the laser module. And a jumper to switch between laser and spindle control.

More Functions, Please!

But milling and laser cutting are not enough. I wanted to turn the desktop CNC mill into a vinyl cutter. You can use vinyl cutters to create stickers for your car. Or create your own T-Shirt patterns with heat transfer vinyl.

It turns out with the right tools it’s really easy. All you need is a drag knife and a 3d printed converter.

You can make the drag knife from a razor blade. Or you can buy a replacement part intended for a professional vinyl cutter. I believe it’s worth to spend $10 on this part rather than making it yourself. This will have a big impact on the quality of your cuts. You can buy a drag knife that fits the 3d printed part here from Banggood.

Thingiverse user [barts] has designed a two-part adapter to fit into the spindle motor holder. You can download it here.

[bart]’s 3D design is brilliant: it uses two thin connections as a spring mechanism. This way the cutter can compensate for uneven build surface and applies pressure more or less evenly. Other designs I found on Thingiverse involved proper springs. To find the right spring for the design can be complicated. The 3D printed spring mechanism, however, works really good.

As I said, the 3D printed model comes with two different parts. The first is the drag knife holder. The second one is the converter which neatly fits into the spindle motor holder. You connect the two parts with M2 screws. This can be a bit complicated since the nuts are inside the spring mechanism and hard to access. One note: put the two 3d printed parts together before you put the drag knife in or it will be even harder.

Preparing the GCODE

We have successfully converted the CNC mill into a vinyl cutter. But just having the hardware doesn’t cut us any good looking stickers. We need to convert a vector object into a language the printer understands. My CNC mill has a board with a GRBL firmware on it. This firmware parses instructions the computer sends and converts it into the movement of the stepper motors. The commands are called G-Code and are also used for 3D printers and other similar machines.

So how to we turn a logo into a vinyl sticker? Ideally, your design is already available in a vector format like SVG since this is much easier to be converted into machine instructions.

I use the free available open-source software Inkscape to convert SVG to G-Code. Inkscape is available for Windows, Linux, and Mac OS X. The Inkscape extension called gcodetools lets you convert vector graphics to gcode. And this extension is already included with the default Inkscape installation.

Inkscape is certainly not the most intuitive vector drawing program. But if you don’t like to draw in Inkscape you can prepare your design in another program. Then you import the design as SVG into Inkscape only to convert it to GCODE

Follow these steps to export the design in G-Code format:

• Convert the object into a path by selecting the design, then Path > Object to Path…
• Start the gcodetools extension:
  Extensions > Gcodetools > Path to Gcode…

The default settings work for me except for the output path. Make sure that you find the exported files. Ticking the “Add numeric suffix to filename” adds a number to the end of the filename. This number will increase with every export.

Preparing the CNC mill

Assuming you have already connected the two 3D printed parts you now have to add the drag knife holder. Adjusting the knife inside the holder is easier before you put it into the holder. The tip of the knife should be visible only a little bit. You can do this with the lead screws on the back of the holder. Once you are happy with the result you can use the second screw to lock the first one in place.

I taped a piece of cardboard to the aluminum work table. I think any other soft surface will do as well. Then you cut out a piece of vinyl and tape it to the cardboard with painter’s tape.

I use CNCjs and bCNC to control the mill. There is nothing special about controlling the mill with a drag knife. Make sure that the knife is zeroed in x and y. Then use a bit of paper to zero the z-axis. Move the paper while you gradually lower the knife towards the bed. When you feel that the knife starts cutting the paper you are all set. The knife holder’s spring mechanism compensates should the knife be too low.

Post-processing the vinyl sticker

If everything went well you now have a piece of the vinyl sticker where the vinyl is cut but the carrier paper is intact. In order to transfer the sticker to your target surface, we have to do a bit of preparation.

Use an Exacto knife or your fingers to peel off any vinyl you don’t need. Sometimes part of the sticker that you still need might lift off. Carefully cut connections to the waste vinyl and press it back down. This is the phase that requires the most concentration. Make sure that you don’t forget to take off tiny parts. It will be much harder to remove them later.

Now glue painter’s tape on top of your sticker. The tape will serve to transfer all the single parts of the sticker to the target surface and keep everything in place. We use painter’s tape because we can easily remove it later on.

Placing the vinyl

Once you are ready to place the sticker on the target surface remove the white carrier paper. The vinyl now only sticks to the painter’s tape with the sticking side open.

Carefully align the sticker on the target surface. I believe professionals sometimes apply soapy water to the surface. This allows you to shift the sticker until it is in a perfect position.

Then press the vinyl as good as you can to the surface by applying pressure to the painter’s tape. Then start peeling off the painter’s tape while leaving the vinyl glued to the surface. Help with a knife to release tiny parts from the painter’s tape.

Shopping Links

Here are again all the links to the products mentioned in this post. I didn’t get paid to advertise these products but by using these links you will be supporting this blog:

3018 3 Axis CNC Router. Around USD $200 from Banggood

2.5W Laser Module to extend the CNC router. ~USD $80 from Banggood

Drag Knife Holder + set of drag knives. ~USD $10 from Banggood

Vinyl sheets in various colors: ~USD $10 from Banggood

Iron-on Vinyl for T-Shirts: ~USD $8 from Banggood