Impulses can be deployed as a C++ library. This packages all your signal processing blocks, configuration and learning blocks up into a single package. You can include this package in your own application to run the impulse locally. In this tutorial you'll export an impulse, and build a desktop application to classify sensor data.
Even though this is a C++ library you can link to it from C applications. See 'Using the library from C' below.
Knowledge required
This tutorial assumes that you know how to build C++ applications, and works on macOS, Linux and Windows. If you're unfamiliar with these tools you can build binaries directly for your development board from the Deployment page in the studio.
Note: This tutorial provides the instructions necessary to build the C++ SDK library locally on your desktop. If you would like a full explanation of the Makefile and how to use the library, please see the deploy your model as a C++ library tutorial.
Looking for examples that integrate with sensors? See the Edge Impulse C++ SDK for Linux.
Make sure you followed the Continuous motion recognition tutorial, and have a trained impulse. Also install the following software:
macOS, Linux
GNU Make - to build the application. make
should be in your PATH.
A modern C++ compiler. The default LLVM version on macOS works, but on Linux upgrade to LLVM 9 (installation instructions).
Windows
MinGW-W64 which includes both GNU Make and a compiler. Make sure mingw32-make
is in your PATH.
We created an example repository which contains a Makefile and a small CLI example application, which takes the raw features as an argument, and prints out the final classification. Clone or download this repository at example-standalone-inferencing.
Head over to your Edge Impulse project, and go to Deployment. From here you can create the full library which contains the impulse and all external required libraries. Select C++ library, and click Build to create the library.
Download the .zip
file and place the contents in the 'example-standalone-inferencing' folder (which you downloaded above). Your final folder structure should look like this:
To get inference to work, we need to add raw data from one of our samples to main.cpp. Head back to the studio and click on Live classification. Then load a validation sample, and click on a row under 'Detailed result'. Make a note of the classification results, as we want our local application to produce the same numbers from inference.
To verify that the local application classifies the same, we need the raw features for this timestamp. To do so click on the 'Copy to clipboard' button next to 'Raw features'. This will copy the raw values from this validation file, before any signal processing or inferencing happened.
Open source/main.cpp in an editor of your choice. Find the following line:
Paste in your raw sample data where you see // Copy raw features here
:
Note: the raw features will likely be longer than what I listed here (the ...
won't compile--I just wanted to demonstrate where the features would go).
In a real application, you would want to make the features[]
buffer non-const. You would fill it with samples from your sensor(s) and call run_classifier()
or run_classifier_continuous()
. See deploy your model as a C++ library tutorial for more information.
Save and exit.
Open a terminal or command prompt, and build the project:
macOS, Linux
Windows
This will first build the inferencing engine, and then build the complete application. After building succeeded you should have a binary in the build/ directory.
Then invoke the local application by calling the binary name:
macOS, Linux
Windows
This will run the signal processing pipeline using the values you provided in the features[]
buffer and then give you the classification output:
Which matches the values we just saw in the studio. You now have your impulse running locally!
Even though the impulse is deployed as a C++ application, you can link to it from C applications. This is done by compiling the impulse as a shared library with the EIDSP_SIGNAL_C_FN_POINTER=1
and EI_C_LINKAGE=1
macros, then link to it from a C application. The run_classifier
can then be invoked from your application. An end-to-end application that demonstrates this and can be used with this tutorial is under example-standalone-inferencing-c.