The presenter introduces the topic and explains the goal of the tutorial. He also gives a brief overview of the previous episode where they took the first steps to interact with the BLE device.

Introduction

The presenter explains how to set up the environment for the application. He discusses the use of the SDBUS C++ library and how to use it to send messages to the BLE device.

Setting Up the Environment

The presenter starts writing the code for the application. He creates a method to connect to the device and read values from it. He also explains how to use a mutex to protect the data shared among different threads.

Writing the Code

The presenter tests the application. He encounters a problem with the BLE device connection and resolves it by using an ethernet cable and disabling the Wi-Fi.

Testing the Application

The presenter discusses the challenges encountered during the process. He suggests using a USB dongle to ignore the internal hardware for better results.

Resolving Challenges

The presenter concludes the tutorial by summarizing the steps taken and the results achieved. He also gives a preview of the next episode where they will explore the alternative MQTT.

Conclusion

Resources & more episodes → <a href="https://mdb.link/iot00005" target="_blank" rel="noreferrer">https://mdb.link/iot00005</a>

Jorge completes the first version of the application on this video. He sends DBus messages to connect to the devices, select the characteristic that has to be read, gets the value and transform it into some native type. He uses the producer-consumer concurrency pattern and finally, he writes the code to disconnect from the device and run and test the final result.

Subscribe to MongoDB YouTube → <a href="https://mdb.link/subscribe" target="_blank" rel="noreferrer">https://mdb.link/subscribe</a>

The video is a tutorial on how to write a C++ application to connect to a Bluetooth Low Energy (BLE) device and read values from it. The presenter explains the process step by step, from setting up the environment, writing the code, to testing the application. The presenter also discusses the challenges encountered during the process and provides solutions.

Adventures in IoT 5: Me and the Devil Bluez - Part 3

Even though Node.JS is the most popular programming language to use with MongoDB, there's no reason you can't use other programming languages - including C++! This video tutorial will use the C++ client library to create a REST API, then create an application that holds information about MarioKart characters. 

Working with MongoDB in C++

Resources & more episodes → <a href="https://mdb.link/iot00004" target="_blank" rel="noreferrer">https://mdb.link/iot00004</a>

Time to write some C++ code. Jorge starts by sending simple DBus messages to Bluez to query and set properties. Then, he uses the same technique to start and stop scanning and listens to signals coming from DBus with information about the devices that are discoverable.

Subscribe to MongoDB YouTube → <a href="https://mdb.link/subscribe" target="_blank" rel="noreferrer">https://mdb.link/subscribe</a>

Adventures in IoT 4: Me and the Devil Bluez - Part 2

In this episode, Jorge covers some relevant Bluetooth Low Energy concepts and puts them in practice by using them in writing the firmware of a Raspberry Pi Pico board. In this firmware, we use the on-board LED, read from the on-board temperature sensor and implement a BLE peripheral that offered two services and a characteristic that depended on measured data and could push notifications.

✅ Sign-up for a free cluster at → <a href="https://mdb.link/free-vXFjpScH8AQ" target="_blank" rel="noreferrer">https://mdb.link/free-vXFjpScH8AQ</a>
✅ Get help on our Community Forums → <a href="https://mdb.link/community-vXFjpScH8AQ" target="_blank" rel="noreferrer">https://mdb.link/community-vXFjpScH8AQ</a>

Adventures in IoT playlist → <a href="https://trymongodb.com/3R38iGX" target="_blank" rel="noreferrer">https://trymongodb.com/3R38iGX</a>
Subscribe to MongoDB YouTube → <a href="https://mdb.link/subscribe" target="_blank" rel="noreferrer">https://mdb.link/subscribe</a>

Adventures in IoT EP2: Turn on BLE (Bluetooth Low Energy)

Resources → <a href="https://mdb.link/iot00001" target="_blank" rel="noreferrer">https://mdb.link/iot00001</a> 

In the first episode of this series, Jorge introduces the project that we will be developing.  It will be a series of sensors that gather noise data that will be collected by a bespoke implementation of a collecting station.  We will explore two mechanisms for the communication between the sensors and the collecting station: BLE and MQTT over WiFi.  Once the data is in the collecting station, we will send it to a MongoDB Atlas cluster on the Cloud using the C++ driver and we will finish the project by showing some potential usages of the data in the Cloud.

Jorge also presents a list of requirements for the development boards and some alternatives that match those requirements and you can use for this or similar projects.

✅ Sign-up for a free cluster at → <a href="https://mdb.link/free-FW8n8IcEwTM" target="_blank" rel="noreferrer">https://mdb.link/free-FW8n8IcEwTM</a>
✅ Get help on our Community Forums → <a href="https://mdb.link/community-FW8n8IcEwTM" target="_blank" rel="noreferrer">https://mdb.link/community-FW8n8IcEwTM</a>

Adventures in IoT playlist → <a href="https://trymongodb.com/3R38iGX" target="_blank" rel="noreferrer">https://trymongodb.com/3R38iGX</a>
Subscribe to MongoDB YouTube → <a href="https://mdb.link/subscribe" target="_blank" rel="noreferrer">https://mdb.link/subscribe</a>

Adventures in IoT EP1: Project Intro

Jorge D. Ortiz-Fuentes

Mobile Developer Advocate

Learn to write firmware of a noise sensor with an ESP32 from scratch using Rust. We use the neopixel to inform the user about the status of the device.

Red Mosquitto: Implement a Noise Sensor With an MQTT Client in an ESP32

This article teaches the process of writing a C++ application from scratch that reads from a Bluetooth Low Energy sensor using DBus and BlueZ.

Plans and Hardware Selection for a Hands-on Implementation of IoT with MCUs and MongoDB

Turn BLE: Implementing BLE Sensors with MCU Devkits

Me and the Devil BlueZ: Implementing a BLE Central in Linux - Part 1

Me and the Devil BlueZ: Reading BLE Sensors From C++

Adventures in IoT with MongoDB

Rishabh Bisht

Product Manager

[Time series](https://www.mongodb.com/time-series) data is a set of data points collected at regular intervals. It’s a common use case in many industries such as finance, IoT, and telecommunications. MongoDB provides powerful features for handling time series data, and in this tutorial, we will show you how to build a C++ console application that uses MongoDB to store time series data, related to the Air Quality Index (AQI) for a given location. We will also take a look at [MongoDB Charts](https://www.mongodb.com/docs/charts/) to visualize the data saved in the time series.

Libraries used in this tutorial:
1. [MongoDB C Driver version: 1.23.0](https://github.com/mongodb/mongo-c-driver/releases)
2. [MongoDB C++ Driver version: 3.7.0](https://github.com/mongodb/mongo-cxx-driver/releases)
3. [cpr library](https://github.com/libcpr/cpr)
4. [vcpkg](https://vcpkg.io/en/index.html)
5. Language standard:  C++17

This tutorial uses Microsoft Windows 11 and [Microsoft Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) but the code used in this tutorial should work on any operating system and IDE, with minor changes.

## Prerequisites
1. [MongoDB Atlas account](https://www.mongodb.com/developer/products/atlas/free-atlas-cluster/) with a cluster created.
2. Microsoft Visual Studio setup with MongoDB C and C++ Driver installed. Follow the instructions in [Getting Started with MongoDB and C++](https://www.mongodb.com/developer/products/mongodb/getting-started-mongodb-c/) to install MongoDB C/C++ drivers and set up the dev environment in Visual Studio.
3. Your machine’s IP address is [whitelisted](https://www.mongodb.com/docs/guides/atlas/network-connections/). Note: You can add 0.0.0.0/0 as the IP address, which should allow access from any machine. This setting is not recommended for production use.
4. API token is generated using [Air Quality Open Data Platform API Token Request Form](https://aqicn.org/data-platform/token/) to fetch AQI for a given location.

## Installation: Libraries
Launch powershell/terminal as an administrator and execute commands shared below.

Step 1: Install [vcpkg](https://vcpkg.io/en/index.html).

```
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
```

Step 2: Install [libcpr/cpr](https://github.com/libcpr/cpr).

```
./vcpkg install cpr:x64-windows
```

This tutorial assumes we are working with x64 architecture. If you are targeting x86, please use this command:

```
./vcpkg install cpr
```

Note: Below warning (if encountered) can be ignored.

```
# this is heuristically generated, and may not be correct
find_package(cpr CONFIG REQUIRED)
target_link_libraries(main PRIVATE cpr::cpr)
```

## Building the application

> Source code available [here](https://github.com/mongodb-developer/get-started-cxx/blob/main/aqi-monitor-console-app/AQIMonitor.cpp)

In this tutorial, we will build an [Air Quality Index](https://en.wikipedia.org/wiki/Air_quality_index) (AQI) monitor that will save the AQI of a given location to a time series collection.
 
The AQI is a measure of the quality of the air in a particular area, with higher numbers indicating worse air quality. The AQI is based on a scale of 0 to 500 and is calculated based on the levels of several pollutants in the air. 

We are going to build a console application from scratch. Follow the steps on how to set up the development environment in Visual Studio from our previous article [Getting Started with MongoDB and C++](https://www.mongodb.com/developer/products/mongodb/getting-started-mongodb-c/), under the section “[Visual Studio: Setting up the dev environment](https://www.mongodb.com/developer/products/mongodb/getting-started-mongodb-c/#visual-studio--setting-up-the-dev-environment).”

### Helper functions
Once we have set up a Visual Studio solution, let’s start with adding the necessary headers and writing the helper functions.
* Make sure to include `<cpr/cpr.h>` to access methods provided by the *cpr* library. 

Note: Since we installed the cpr library with vcpkg, it automatically adds the needed include paths and dependencies to Visual Studio.

* [Get the connection string](https://www.mongodb.com/docs/guides/atlas/connection-string/) (URI) to the cluster and create a new environment variable with key as `“MONGODB_URI”` and value as the connection string (URI). It’s a good practice to keep the connection string decoupled from the code.
Similarly, save the API token obtained in the Prerequisites section with the key as `“AQICN_TOKEN”`.

Navigate to the Solution Explorer panel, right-click on the solution name, and click “Properties.” Go to Configuration Properties > Debugging > Environment to add these environment variables as shown below.

![Setting environment variables in Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/setting_environment_variables_3aee66f0ef.png)

* `“getAQI”` function makes use of the *cpr* library to make a call to the REST API, fetching the AQI data. The response to the request is then parsed to get the AQI figure.
* `“saveToCollection”` function saves the given AQI figure to the time series collection. Please note that adding the `“timestamp”` key-value pair is mandatory. A missing timestamp will lead to an exception being thrown. Check out different `“timeseries”` Object Fields in [Create and Query a Time Series Collection — MongoDB Manual](https://www.mongodb.com/docs/manual/core/timeseries/timeseries-procedures/#std-label-timeseries-create-query-procedures). 

```
#pragma once


#include <mongocxx/client.hpp>
#include <bsoncxx/builder/list.hpp>
#include <bsoncxx/builder/stream/document.hpp>
#include <bsoncxx/json.hpp>
#include <mongocxx/uri.hpp>
#include <mongocxx/instance.hpp>


#include <iostream>
#include <cpr/cpr.h>


using namespace std;


std::string getEnvironmentVariable(std::string environmentVarKey)
{
	char* pBuffer = nullptr;
	size_t size = 0;
	auto key = environmentVarKey.c_str();
	
	// Use the secure version of getenv, ie. _dupenv_s to fetch environment variable.  
	if (_dupenv_s(&pBuffer, &size, key) == 0 && pBuffer != nullptr)
	{
		std::string environmentVarValue(pBuffer);
		free(pBuffer);
		return environmentVarValue;
	}
	else
	{
		return "";
	}
}


int getAQI(std::string city, std::string apiToken)
{
	// Call the API to get the air quality index.
	std::string aqiUrl = "https://api.waqi.info/feed/" + city + "/?token=" + apiToken;
	auto aqicnResponse = cpr::Get(cpr::Url{ aqiUrl });


	// Get the AQI from the response
	if(aqicnResponse.text.empty())
	{
		cout << "Error: Response is empty." << endl;
		return -1;
	}
	bsoncxx::document::value aqicnResponseBson = bsoncxx::from_json(aqicnResponse.text);
	auto aqi = aqicnResponseBson.view()["data"]["aqi"].get_int32().value;
	return aqi;
}


void saveToCollection(mongocxx::collection& collection, int aqi)
{
	auto timeStamp = bsoncxx::types::b_date(std::chrono::system_clock::now());


	bsoncxx::builder::stream::document aqiDoc = bsoncxx::builder::stream::document{};
	aqiDoc << "timestamp" << timeStamp << "aqi" << aqi;
	collection.insert_one(aqiDoc.view());


	// Log to the console window.
	cout << " TimeStamp: " << timeStamp << " AQI: " << aqi << endl;
}
```

### The main() function
With all the helper functions in place, let’s write the main function that will drive this application.
* The main function creates/gets the time series collection by specifying the `“collection_options”` to the `“create_collection”` method. 
Note: MongoDB creates collections implicitly when you first reference the collection in a command, however a time series collection needs to be created explicitly with “[create_collection](https://mongocxx.org/api/mongocxx-3.7.0/classmongocxx_1_1database.html#a9ee98d7fb1fc703d262764c2643361f8)”. 
* Every 30 minutes, the program gets the AQI figure and updates it into the time series collection. Feel free to modify the time interval as per your liking by changing the value passed to `“sleep_for”`.

```
int main()
{
	// Get the required parameters from environment variable.
	auto mongoURIStr = getEnvironmentVariable("MONGODB_URI");
	auto apiToken = getEnvironmentVariable("AQICN_TOKEN");
	std::string city = "Delhi";
	static const mongocxx::uri mongoURI = mongocxx::uri{ mongoURIStr };


	if (mongoURI.to_string().empty() || apiToken.empty())
	{
		cout << "Invalid URI or API token. Please check the environment variables." << endl;
		return 0;
	}


	// Create an instance.
	mongocxx::instance inst{};
	mongocxx::options::client client_options;
	auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
	client_options.server_api_opts(api);
	mongocxx::client conn{ mongoURI, client_options };


	// Setup Database and Collection.
	const string dbName = "AQIMonitor";
	const string timeSeriesCollectionName = "AQIMonitorCollection";


	// Setup Time Series collection options.
	bsoncxx::builder::document timeSeriesCollectionOptions =
	{
	   "timeseries",
		{
		  "timeField", "timestamp",
		  "granularity", "minutes"
		}
	};


	auto aqiMonitorDB = conn[dbName];
	auto aqiMonitorCollection = aqiMonitorDB.has_collection(timeSeriesCollectionName)
		? aqiMonitorDB[timeSeriesCollectionName]
		: aqiMonitorDB.create_collection(timeSeriesCollectionName, timeSeriesCollectionOptions.view().get_document().value);


	// Fetch and update AQI every 30 minutes.
	while (true)
	{ 
		auto aqi = getAQI(city, apiToken);
		saveToCollection(aqiMonitorCollection, aqi);
		std::this_thread::sleep_for(std::chrono::minutes(30));
	}


	return 0;
}
```

When this application is executed, you can see the below activity in the console window.

![AQI Monitor application in C++ with MongoDB time series](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/aqi_monitor_application_d8d0541782.png)

You can also see the time series collection in Atlas reflecting any change made via the console application.

![MongoDB time series in MongoDB Atlas](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_time_series_04e5ef6c59.png)

## Visualizing the data with MongoDB Charts
We can make use of MongoDB Charts to visualize the AQI data and run aggregation on top of it.

Step 1: Go to [MongoDB Charts](https://cloud.mongodb.com/charts/) and click on “Add Dashboard” to create a new dashboard — name it “AQI Monitor”.

Step 2: Click on “Add Chart”.

Step 3: In the “Select Data Source” dialog, go to the “Project” tab and navigate to the time series collection created by our code.

![Selecting data source for MongoDB Charts](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/selecting_data_source_5050d98116.png)

Step 4: Change the chart type to “Continuous Line”. We will use this chart to display the AQI trends over time.

Step 5: Drag and drop the “timestamp” and “aqi” fields into the X axis and Y axis respectively. You can customize the look and feel (like labels, color, and data format) in the “Customize” tab. Click “Save and close” to save the chart.

![MongoDB Charts with time series](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_charts_497c6bda95.gif)

Step 6: Let’s add another chart to display the maximum AQI — click on “Add Chart” and select the same data source as before.

Step 7: Change the chart type to “Number”.

Step 8: Drag and drop the “aqi” field into “Aggregation” and change Aggregate to “MAX”.

![MongoDB Charts with time series](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/charts_with_time_series_73f28aed56.gif)

Step 9: We can customize the chart text to change color based on the AQI values. Let’s make the text green if AQI is less than or equal to 100, and red otherwise. We can perform this action with the conditional formatting option under Customize tab.

![Formatting options in MongoDB Charts](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/formatting_options_e6d6330e57.png)

Step 10: Similarly, we can add charts for minimum and average AQI. The dashboard should finally look something like this:

![MongoDB Charts dashboard](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_charts_dashboard_3fb5198f14.png)

Tip: Change the dashboard’s auto refresh settings from “Refresh settings” button to choose a refresh time interval of your choice for the charts.

![MongoDB Charts refresh settings](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_charts_refresh_settings_c528f263bc.png)

## Conclusion
With this article, we covered creating an application in C++ that writes data to a MongoDB time series collection, and used it further to create a MongoDB Charts dashboard to visualize the data in a meaningful way. The application can be further expanded to save other parameters like [PM2.5](https://en.wikipedia.org/wiki/Particulates#Size,_shape_and_solubility_matter) and temperature. 

Now that you've learned how to create an application using the MongoDB C++ driver and MongoDB time series, put your new skills to the test by building your own unique application. Share your creation with the [community](https://www.mongodb.com/community/forums/) and let us know how it turned out!


Learn how to build a C++ console application that uses MongoDB to store time series data, related to the Air Quality Index (AQI) for a given location.

MongoDB Time Series With C++

Hey there, C and C++ developers! Today, I want to talk about a very sensitive topic for all of us. A thing that has caused pain and shame in the community. A thing that has affected our productivity and sometimes even our mental health. I am not referring to compiler errors, but to building complex projects and using third-party dependencies in them.

Traditionally, we used Makefiles to build our C and C++ projects and depended on having our third-party dependencies installed in our development systems or their sources included in our project in one way or another. The tools have evolved a lot through the last couple of decades, but not everybody is using them completely or even at all to build their projects.

Unless you live under a rock, you have probably seen what your fellow developers do when they use other powerful backend programming languages. Golang has support for third-party modules built-in. You just mention the URL of the third-party repository and it takes care of the rest. Jealous? Rust's cargo tool takes care of building your project and managing all its dependencies even when the project is distributed into several workspaces. Envious? Ashamed no more! Let me show you how to use CMake and Conan within VS Code.

This article is aimed at C or C++ developers who work on projects that produce binaries or libraries and want to be able to use third-party dependencies. In our case, we will be using the [MongoDB driver for C++](https://www.mongodb.com/docs/drivers/cpp/).

In this article, I will:

-   Create an example project from scratch with a directory structure that can be used to work with one or more libraries and a binary.
-   Write the instructions to build the different pieces of the project and link them together.
-   Create the configuration to use a third-party dependency using a package manager.
-   Put all these pieces together and make them work with VS Code.


## Your project

We are going to focus on a project that produces a library, which uses a third-party package. The library is then used together with some other source code to produce a binary. The same structure can be extended to have more libraries or even more binaries. In this case, the third-party package is the MongoDB driver, which allows you to connect to a MongoDB Atlas cluster or a local MongoDB database.

1.  This is the basic directory structure:
    ```JSON
    ├── LibraryN
    │ ├── include
    │ │ └── LibraryN.h
    │ └── src
    │ └── LibraryN.cpp
    └── src
        └── main.cpp
    ```
2.  In the header `libraryN.h`, we add the traditional protection to avoid multiple inclusion:
    
    ```cpp
    #ifndef _LIBRARY_N_H_
    #define _LIBRARY_N_H_
    
    #endif
    ```
3.  Inside of this preprocessor directives, we are going to define a class:
    
    ```cpp
    class MDBClient {
    };
    ```
4.  And its constructor:
    
    ```cpp
    public:
    MDBClient();
    ```
5.  Now, we are going to write the implementation code for this library in `libraryN.cpp`. We start by including the header that we have just declared:
    
    ```cpp
    #include "libraryN.h"
    ```
6.  Then, we define the implementation of the constructor that we declared in the header:
    
    ```cpp
    MDBClient::MDBClient()
    {
    }
    ```
7.  To be able to use the MongoDB driver here, we need to include the header for the desired part of the driver. In this case, we are going to create an instance:
    
    ```cpp
    #include <mongocxx/instance.hpp>
    ```
8.  We can now use the instance in the constructor:
    
    ```cpp
    mongocxx::instance inst{};
    ```
9.  And finally, we have to write the code that uses the library from the executable. We include the header of the library in `main.cpp`:
    
    ```cpp
    #include "libraryN.h"
    ```
10. We declare the main function here, which returns 0:
    
    ```cpp
    int main(int argc, char const *argv[])
    {
        return 0;
    }
    ```
11. And we finish by creating an instance of the class that we defined in the library:
    
    ```cpp
    auto mc = MDBClient{};
    ```


## Create the instructions to build

We are going to use CMake as the build system for our project. The instructions to CMake are provided in the `CMakeLists.txt`.

1.  We start by defining the minimum version of CMake that we allow to be used with our project.
    
    ```cmake
    cmake_minimum_required(VERSION 3.15)
    ```
2.  Then, we define the project using a name, a version and the language(s). This would also work for a C project, but in this case, we are going to use C++:
    
    ```cmake
    project(CoolProject VERSION 0.1 LANGUAGES CXX)
    ```
3.  The first actual instructions to build the project will be used to tell CMake to include our library. First, we include the sources &#x2013;a single file, in this case&#x2013; and then we provide the corresponding header files.
    
    ```cmake
    add_library(libraryN STATIC LibraryN/src/LibraryN.cpp)
    target_include_directories(libraryN PUBLIC LibraryN/include)
    ```
4.  Finally, we add the code for the executable and link the library that we defined in the previous step.
    
    ```cmake
    add_executable(${PROJECT_NAME} src/main.cpp)
    target_link_libraries(${PROJECT_NAME}
      PRIVATE
        libraryN)
    ```


## Configure the dependencies

The build instructions that we have just written would be suitable for projects with one library and an executable. You could add more libraries and other executables using the same CMake commands with the corresponding data. But if you want to bring in a third-party dependency, your options with CMake are more painful. This is where Conan comes to our rescue.

[Conan](https://conan.io/) is an open-source package manager for C and C++ that simplifies the process of integrating third-party dependencies in our project. It is an alternative to Microsoft's [vcpkg](https://vcpkg.io/en/), but they have slightly different approaches. They both have repositories of third-party dependencies and can be configured to include the ones that you need in your project. However, while vcpkg uses a series of tags that define the versions of the dependencies in the repository that are tested to work together, Conan allows you to choose independent versions for each dependency. You can choose individual versions with vcpkg, but it requires some extra effort.

1.  We must have [Conan installed](https://docs.conan.io/2/installation.html). In my case, I went with [Homebrew](https://formulae.brew.sh/formula/conan).
2.  The first thing we need to do is to check if the package we want to use &#x2013;MongoDB C++ driver&#x2013; is available in [Conan Center](https://conan.io/center). So we visit that page and type "mongo" in the search box. Conan Center offers both the `mongo-c-driver` and the `mongo-cxx-driver`. We will use the second, so click on it. 
![Conan center recipes][1]
3.  On the `mongo-cxx-driver` page, it suggests using a simple `conanfile.txt` or a `conanfile.py`. We will go with the file with "txt" extension, because although it is less versatile than the Python configuration, it is enough for our needs in this example. So, let's create a `conanfile.txt` with this content:
    
    ```
    [requires]
    mongo-cxx-driver/3.8.1
    [generators]
    CMakeDeps
    CMakeToolchain
    [layout]
    cmake_layout
    ```

## Project setup

Also, the page for the dependency suggests adding a couple of lines to our CMake configuration.

1.  We add a line to the `CMakeLists.txt`, right after the project declaration line, to find the package that Conan will install.
    
    ```cmake
    find_package(mongocxx REQUIRED)
    ```
2.  Add a line to the bottom of the block for the library that will instruct CMake to link the dependency to it. We link the dependency to the library and not the executable because this is where we use the dependency.
    
    ```cmake
    target_link_libraries(libraryN
      PRIVATE
          mongo::mongocxx_static)
    ```
3.  We use the command line to finish setting up the project. First, we create the profile that contains information about our toolchain and the type of build, which is going to be "Release." You can create a debug profile by copying the file that has been created and changing the `build_type` to "Debug" in the new file.
    
    ```shell
    conan profile detect # If you don't have a conan profile yet
    ```
4.  Then, we can install the packages and tell Conan to produce the configuration. You can use the next command again with `--profile=debug` (or the filename of your debug profile), if you also want to also install the debug version of the packages.
    
    ```shell
    conan install . --build=missing
    ```
5.  At this point, we should be able to build the project from the command line using the preset created by Conan. We can list CMake presets using the following command:
    
    ```shell
    cmake --list-presets
    ```
6.  There should be only one configuration preset available &#x2013;or two if you also installed the debug one&#x2013;, so let's use it to configure the project:
    
    ```shell
    cmake --preset conan-release
    ```
7.  And we can build the project using the corresponding build preset:
    
    ```shell
    cmake --build --preset conan-release
    ```
8.  Hug your partner, your friend, or your pet, because you have successfully built the project. Yippee ki-yay, my friend!


## Use from VS Code

Let's clean the build to see how this works with VS Code.

1.  We need to specify the directory that Conan has used for the cache.
    
    ```shell
    cmake --build build/Release  --target clean
    ```
2.  And before we try to build from VS Code, we have to be aware that you will need to have two extensions installed: [CMake](https://marketplace.visualstudio.com/items?itemName=twxs.cmake) and [CMake Tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools).
![VSCode extensions][2]
3.  From the command palette (`View -> Command Palette` or `Cmd+S+P`), we invoke "Developer: window reload." VS Code will reload the directory, check the contents of the `CMakeLists.txt`, and offer us a choice of one of the available profiles. We should choose one of the presets provided by Conan.
4.  To build the project from VS Code, click on the CMake Tools icons on the sidebar.
![CMake-Tools usage][4]
5.  We should be able to build, run, and even debug without any problems.


## Conclusion

In this tutorial, we have explored some options to sharpen our tools. We can now use CMake for building mid-sized projects and Conan to take care of our dependencies. We can use these two to build from the command line, but we have gone a step further and used that configuration from our beloved ~~Emacs~~ VS Code.

Stay curious, hack your code, see you next time!


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0120609b13ec8457/667d4327abc513a6995d026c/conan_center_recipes.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt3e4f0950f710a54c/667d441b45c6f719ed35cff8/vscode_extensions.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt2f15aa18e208d2a4/667d424d45c6f7dcd835cfda/conan_center_recipes.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt90c7d17d5b6d1d85/667d42075e288d6792a20618/cmake_tools_usage.png

CMake + Conan + VS Code

Do you have a cool idea for a device that you may consider producing and selling? Would you want to have some new functionality implemented for your smart home? Do you want to understand how IoT works with a real example that we can work with from beginning to end? Are you a microcontroller aficionado and want to find some implementation alternatives? If the answer is yes to any of these questions, welcome to this series of articles and videos.

# Table of Contents

1.  [The idea and the challenge](#sec01)
2.  [The vision, the mission and the product](#sec02)
3.  [Rules of engagement](#sec03)
4.  [The plan](#sec04)
5.  [Hardware selection](#sec05)
    1.  [Raspberry Pi Pico W](#ssec05-01)
    2.  [Micro:bit](#ssec05-02)
    3.  [Adafruit Circuit Playground Bluefruit](#ssec05-03)
    4.  [Adafruit Feather nRF52840 Sense](#ssec05-04)
    5.  [Espressif ESP32-C6-DevKitC-1](#ssec05-05)
6.  [Recap and future content](#sec06)

<a id="sec01"></a>
# The idea and the challenge

For a while, I have been implementing many automations at home using third-party hardware and software products. This brings me a lot of joy and, in most cases, improves the environment my family and I live in.  In the past, this used to be harder, but nowadays, the tools and their compatibility have improved greatly.  You can start with something as trivial but useful as turning on the garden lights right after sunset and off at the time that you usually go to bed.  But you can easily go much further.

For example, I have a door sensor that is installed in my garage door that triggers a timer when the door is opened and turns a light red after six minutes.  This simple application of domotics has helped me to avoid leaving the door open countless times.

All the fun, and sometimes even frustration, that I have experienced implementing these functionalities, together with the crazy ideas that I sometimes have for creating and building things, have made me take a step forward and accept a new challenge in this area.  So I did some thinking and came up with a project that combined different requirements that made it suitable to be used as a proof of concept and something that I could share with you.

Let me describe the main characteristics of this project:

-   It should be something that a startup could do (or, at least, close enough.)  So, I will share the vision and the mission of that wannabe startup.  But most importantly, I will introduce the concept for our first product.  You don't have to *buy* the idea, nor will I spend time trying to demonstrate that there is a suitable business need for that, in other words, this is a BPNI (business plan not included) project.
-   The idea should involve something beyond just a plain microcontroller (MCU).  I would like to have some of those, maybe even in different rooms, and have their data collected in some way.
-   The data will be collected wirelessly. Having several sensors in different places, the wired option isn't very appealing.  I will opt for communications implemented over radio frequencies: Bluetooth and WiFi.  I might consider using ZigBee, Thread, or something similar in the future if there is enough interest.  Please be vocal in your comments on this article.
-   I will use a computer to collect all the sensor measurements locally and send them to the cloud.
-   The data is going to be ingested into MongoDB Atlas and we will use some of its IoT capabilities, such as time series collections and real-time analytics.
-   Finally, I'm going to use some programming languages that are on the edge or even out of my comfort zone, just to prove that they shouldn't be the limitation.

<a id="sec02"></a>
# The vision, the mission and the product

**Vision**: we need work environments that enhance our productivity.
Consider that technology, and IoT in particular, can be helpful for that.

**Mission**: We are going to create, sell, and support IoT products that will help our users to be more productive and feel more comfortable in their work environments.

The first product in the pipeline is going to help our customers to measure and control noise levels in the workspace.

Hopefully, by now you are relieved that this isn't going to be another temperature sensor tutorial. Yippee-ki-yay!

Let's use an implementation diagram that we will refine in the future.  In the diagram, I have included an *undetermined* number of sensors (actually, 5) to measure the noise levels in different places, hence the ear shape used for them.  In my initial implementation, I will only use a few (two or three) with the sole purpose of verifying that the collecting station can work with more than one at any given time.  My first choice for the collecting station, which is represented by the inbox icon, is to use a Raspberry Pi (RPi) that has built-in support for Bluetooth and WiFi. Finally, on the top of the diagram, we have a MongoDB Atlas cluster that we will use to store and use the sensor data.

![Architecture diagram][1]

<a id="sec03"></a>
# Rules of engagement

As I mentioned above, I didn't want to do a project that was only about implementing a sensor with an MCU and reading values from it.  There are plenty of those and some of them are amazing, so my contribution would be worthless. Instead, my goal is to work on the different relevant aspects of a real-world project that uses custom devices. That includes MCU firmware coding, device communication, ingestion of IoT data, and working with it.

But, at the same time, I didn't want to spend more time on this project than strictly required.  So, I will start by sharing with you a plan for the implementation of the different parts of the project, including some alternatives for the implementation.  I will start with what I consider to be the most interesting one, but I might switch gears if the step I am working on begins to become too complex (for me).  If you feel that the option that I have decided to skip still makes sense, feel free to add a comment to encourage me to continue exploring it.  I might come back to it after the main project is finished.

![Devices for the project][2]

I also want to let you know that I am planning to use different programming languages throughout this project.  I consider myself quite fluent in some, like Rust and Go, but with others, like Python or C++, it has been a long while since I had to push any actual commits on any production branch of any real-world project.  Still, I have challenged myself to work with them and share the code with you.  I want to refresh my hands-on experience with them and learn from your comments to do things better.

A word on the tools, too.  My friends and colleagues know that I am an Emacs user and fan, but my goal is that this content is useful to the largest number of people.  I know that you may have other preferred editors, so I have decided to use what I consider the most popular one nowadays, Visual Studio Code, as I did with the [Rust](https://www.youtube.com/watch?v=_jDKeOtOiEo) videos in the past. Please forget my mistakes when using it.

Finally, there are some things that I won't be covering in this project, both for the sake of brevity and for my lack of knowledge of them.  The most obvious ones are creating custom PCBs with the components and 3D printing a case for the resulting device.  But most importantly, I won't be implementing firmware for all of the devkits that I will select and even less in different languages.  Just some of the boards in some of the languages.  As we lazy people like to say, this is left as an exercise to the reader.

<a id="sec04"></a>
# The plan

Coming back to the goal of this project, it is to mimic what one would do when one wants to create a new device from scratch.  I will start, then, by selecting some microcontroller devkits that are available on the market.  That is the first step and it is included in this article.

One of the main features of the hardware that I plan to use is to have some way of working wirelessly.  I plan to have some sensors, and if they require a wired connection to the collecting station, it would be a very strong limitation. Thus, my next step is to implement this communication.  I have considered two alternatives for the communication.  The first one is Bluetooth Low Energy (BLE) and the second one is MQTT over WiFi.  I will give a more detailed explanation when we get to them.  From the perspective of power consumption, the first option seems to be better, and consuming less power means batteries that last longer and happier users.

But, there seems to be less (complete) documentation on how to implement it.  For example, I could find neither good documentation for the BLE library that comes with MicroPython nor anything on how to use BLE with Bluez and DBus.  Also, if I successfully implement both sides of the BLE communication, I need to confirm that I can make it work concurrently with more than one sensor.

My second and third steps will be to implement the peripheral role of the BLE communication on the microcontroller devkits and then the central role on the RPi.

I will continue with the implementation of the WiFi counterparts.  Step 4 is going to be making the sensors publish their measurements via MQTT over WiFi, and Step 5 will be to have the Raspberry Pi subscribe to the MQTT service and receive the data.

Eventually, in Step 6, I will use the MongoDB C++ driver to upload the data to a MongoDB Atlas cluster.  Once the data is ingested by the MongoDB Atlas cluster, we will be able to enjoy the advantages it offers in terms of storing and archiving the data, querying it, and using real-time analytics and visualization.

So, this is the list of steps of the plan:

1.  Project intro (you are here)
2.  BLE peripheral firmware
3.  BLE central for Raspberry Pi OS
4.  MQTT publisher firmware
5.  MQTT subscriber for Raspberry Pi OS
6.  Upload data from Raspberry Pi OS to MongoDB Atlas clusters
7.  Work with the data using MongoDB

I have a couple of ideas that I may add at the end of this series, but for now, this matches my goals and what I wanted to share with you.  Keep in mind that it is also possible that I will need to include intermediate steps to refine some code or include some required functionality.  I am open to suggestions for topics that can be added and enhancements to this content.  Send them my way while the project is still in progress.

<a id="sec05"></a>
# Hardware selection

I will start this hands-on part by defining the features that I will be using and then come up with some popular and affordable devkit boards that implement those features or, at least, can be made to do so.  I will end up with a list of devkit boards.  It will be nothing like the "top devkit boards" of this year, but rather a list of suggested boards that can be used for a project like this one.

Let's start with the features:

-   They have to implement at least one of the two radio-frequency communication standards: WiFi and/or Bluetooth.
-   They have to have a microphone or some pins that allow me to connect one.
-   Having another sensor on board is appreciated but not required.  Reading the temperature is extremely simple, so I will start by using that instead of getting audio.  I will focus on the audio part later when the communications are implemented and working.
-   I plan to have independent sensors, so it would be nice if I could plug a battery instead of using the USB power. Again, a nice feature, but not a must-have.
-   Last, but not least, having documentation available, examples, and a vibrant community will make our lives easier.

<a id="ssec05-01"></a>
## Raspberry Pi Pico W

![Raspberry Pi Pico W][3]

The [Rasberry Pi Pico (RP2)](https://www.raspberrypi.com/products/raspberry-pi-pico/) is produced by the same company that sells the well-known Raspberry Pi single-board computers, but it is a microcontroller board with its own RP-2040 chip.  The RP-2040 is a dual-core Arm Cortex-M0+ processor.  The W model includes a fully certified module that provides 802.11n WiFi and Bluetooth 5.2.  It doesn't contain a microphone in the devkit board, but there are [examples](https://github.com/henriwoodcock/pico-wake-word) and [code](https://github.com/ArmDeveloperEcosystem/microphone-library-for-pico) available for connecting an electret microphone.  It does have a temperature sensor, though. It also doesn't have a battery socket so we will have to use our spare USB chargers.

Finally, in terms of creating code for this board, we can use:

-   [MicroPython](https://micropython.org/), which is an implementation of Python3 for microcontrollers.  It is efficient and offers the niceties of the Python language: easy to learn, mature ecosystem with many libraries, and even REPL.
-   [C/C++](https://www.raspberrypi.com/documentation/microcontrollers/c_sdk.html) that provide a lower-level interface to extract every bit of juice from the board.
-   [JavaScript](https://kalumajs.org/) as I have learned very recently.  The concept is similar to the one in the MicroPython environment but less mature (for now).
-   There are some Rust crates for this processor and the board, but it may require extra effort to use BLE or WiFi using the [embassy crate](https://embassy.dev/).

<a id="ssec05-02"></a>
## Micro:bit

![Micro:bit][4]

The BBC [micro:bit](https://microbit.org/) is a board created for learning purposes.  It comes with several built-in sensors, including a microphone, and LEDs that we can use to get feedback on the noise levels.  It uses a Nordic nRF52833 that features an ARM Cortex-M4 processor with a full Bluetooth Low Energy stack, but no WiFi.  It has a battery socket and it can be bought with a case for AA batteries.

The educational goal is also present when we search for options to write code.  These are the main options:

-   [Microsoft MakeCode](https://microbit.org/get-started/getting-started/get-coding/) which is a free platform to learn programming online using a graphical interface to operate with different blocks of code.
-   Python using [MicroPython](https://tech.microbit.org/software/micropython/) or its own [web interface](https://python.microbit.org/v/3).
-   [C/C++ with the Arduino IDE](https://learn.adafruit.com/use-micro-bit-with-arduino/overview).
-   Rust, because the [introductory guide for embedded Rust](https://docs.rust-embedded.org/discovery/microbit/) uses the microbit as the reference board. So, no better board to learn how to use Rust with embedded devices.  BLE is not in the guide, but we could also use the embassy [nrf-softdevice](https://github.com/embassy-rs/nrf-softdevice) crate to implement it.

<a id="ssec05-03"></a>
## Adafruit Circuit Playground Bluefruit

![Circuit Playground Bluefruit][5]

[This board](https://www.adafruit.com/product/4333) is also aimed at people who want to have their first contact with electronics.  It comes with a bunch of sensors, including temperature one and a microphone, and it also has some very nice RGB LEDs.  Its main chip is a Nordic nRF52840 Cortex M4 processor with Bluetooth Low Energy support.  As was the case with the micro:bit board, there's no WiFi support on this board.  It has a JST PH connector for a lipo battery or an AAA battery pack.

It can be used with Microsoft MakeCode, but its preferred programming environment is [CircuitPython](https://circuitpython.org/).  CircuitPython is a fork of MicroPython with some specific and slightly more refined libraries for Adafruit products, such as this board. If you want to use Rust, there is a [crate for an older version of this board](https://crates.io/crates/circuit_playground_express), without BLE support.  But then again, we could use the embassy crates for that purpose.

<a id="ssec05-04"></a>
## Adafruit Feather nRF52840 Sense

![Feather Sense][6]

Adafruit Feather is a platform that provides a consistent interface across different chipsets, so you can connect to them any of the companion feather wings, i.e., accessory boards.  [This model](https://learn.adafruit.com/adafruit-feather-sense/overview) is also based on the Nordic nRF52840 Cortex M4 and offers Bluetooth Low Energy but no WiFi.  It comes with many on-board sensors, including microphone and temperature.  It also features an RGB LED and a JST PH connector for a battery that can be charged using the USB connector.

While [this board](https://learn.adafruit.com/adafruit-feather-sense) can also be used to learn, I would argue that it's more aimed at prototyping and the programming options are:

-   CircuitPython as with all the Adafruit boards.
-   C/C++ with the Arduino IDE.
-   Rust, using the previously mentioned crates.

<a id="ssec05-05"></a>
## Espressif ESP32-C6-DevKitC-1

![ESP32-C6][7]

In contrast with all the ARM-based processors of the other boards, [this board](https://csa-iot.org/all-solutions/zigbee/) features a RISC-V single-core processor and a WROOM module that provides not only WiFi and Bluetooth connectivity but also [Zigbee](https://csa-iot.org/all-solutions/zigbee/) and [Thread](https://www.threadgroup.org/What-is-Thread/Thread-Benefits) (both are network protocols specifically designed for IoT).  It has no sensors on-board, but it does have an LED and two USB-C ports, one for UART communications and the other one for USB Type-C serial communications.

Espressif boards have traditionally been [programmed in C/C++](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/cplusplus.html), but during the last year, they have been promoting [Rust as a supported environment](https://github.com/esp-rs).  It even has an [introductory book](https://esp-rs.github.io/book/) that explains the basics for their boards.

<a id="sec06"></a>
# Recap and future content

:youtube[]{vid=FW8n8IcEwTM}

In this article, we have introduced the project that I will be developing.  It will be a series of sensors that gather noise data that will be collected by a bespoke implementation of a collecting station.  I will explore two mechanisms for the communication between the sensors and the collecting station: BLE and MQTT over WiFi.  Once the data is in the collecting station, I will send it to a MongoDB Atlas cluster on the Cloud using the C++ driver and we will finish the project by showing some potential uses of the data in the Cloud.

I have presented you with a list of requirements for the development boards and some alternatives that match those requirements, and you can use it for this or similar projects.  In our next episode, I will try to implement the BLE peripheral role in one or more of the boards.

If you have any questions or feedback, head to the [MongoDB Developer Community forum](https://www.mongodb.com/community/forums/).


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt28e47a9dd6c27329/65533c1b9f2b99ec15bc9579/Adventures_in_IoT.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltf77df78f4a2fdad2/65536b9e647c28790d4e8033/devices.jpeg
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt38747f873267cbc5/655365a46053f868fac92221/rp2.jpeg
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0d38d6409869d9a1/655365b64d285956b1afabf2/microbit.jpeg
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltfa0bf312ed01d222/655365cc2e0ea10531178104/circuit-playground.jpeg
  [6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt5ed758c5d26c0382/655365da9984b880675a9ace/feather.jpeg
  [7]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt1ad337c149332b61/655365e9e9c23ce2e927441b/esp32-c6.jpeg

In the first of this series, learn the hands-on IoT project we will be delivering, the architecture that will be implemented, and the step-by-step approach we'll take.

This article will show you how to utilize Microsoft Visual Studio to compile and install the [MongoDB C](https://www.mongodb.com/docs/drivers/c/) and [C++ drivers](https://www.mongodb.com/docs/drivers/cxx/) on Windows, and use these drivers to create a console application that can interact with your MongoDB data by performing basic [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) operations.

Tools and libraries used in this tutorial:

1. Microsoft Windows 11
2. Microsoft Visual Studio 2022 17.3.6
3. Language standard: C++17
4. MongoDB C Driver version: 1.23
5. MongoDB C++ Driver version: 3.7.0
6. boost: 1.80.0
7. Python: 3.10
8. CMake: 3.25.0

## Prerequisites

1. [MongoDB Atlas account](https://www.mongodb.com/developer/products/atlas/free-atlas-cluster/) with a cluster created.
2. *(Optional)* [Sample dataset](https://www.mongodb.com/developer/products/atlas/atlas-sample-datasets/) loaded into the Atlas cluster.
3. Your machine’s IP address is [whitelisted](https://www.mongodb.com/docs/guides/atlas/network-connections/). Note: You can add *0.0.0.0/0* as the IP address, which should allow access from any machine. This setting is not recommended for production use.

## Installation: IDE and tools

Step 1: Install Visual Studio: [Download Visual Studio Tools - Install Free for Windows, Mac, Linux](https://visualstudio.microsoft.com/downloads/).

In the Workloads tab during installation, select “Desktop development with C++.”

![Microsoft Visual Studio installation](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/microsoft_visual_studio_installation_4e60668543.png)

Step 2: Install CMake: [Download \| CMake](https://cmake.org/download/)

* For simplicity, choose the installer.
* In the setup, make sure to select “Add CMake to the system PATH for all users.” This enables the CMake executable to be easily accessible.

![Install options for CMake](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/install_options_for_cmake_37b887a6fb.png)

Step 3: Install Python 3: [Download Python](https://www.python.org/downloads/).

Step 4: *(Optional)* Download boost library from [Boost Downloads](https://www.boost.org/users/download/) and extract it to *C:\boost*.

## Installation: Drivers

> Detailed instructions and configurations available here:
> 
> 
> * [Installing the mongocxx driver](https://mongocxx.org/mongocxx-v3/installation/)
> * [Installing the MongoDB C Driver (libmongoc) and BSON library (libbson)](http://mongoc.org/libmongoc/current/installing.html)

### Step 1: Install C Driver

C++ Driver has a dependency on C driver. Hence, we need to install C Driver first.

* Download C Driver
    * Check compatibility at [Windows - Installing the mongocxx driver](https://mongocxx.org/mongocxx-v3/installation/windows/) for the driver to download.
    * Download release tarball — [Releases · mongodb/mongo-c-driver](https://github.com/mongodb/mongo-c-driver/releases) — and extract it to *C:\Repos\mongo-c-driver-1.23.0*.
* Setup build via CMake
    * Launch powershell/terminal as an administrator.
    * Navigate to *C:\Repos\mongo-c-driver-1.23.0* and create a new folder named *cmake-build* for the build files.
    * Navigate to *C: \Repos\mongo-c-driver-1.23.0\cmake-build*.
    * Run the below command to configure and generate build files using CMake. 
    
```
cmake -G "Visual Studio 17 2022" -A x64 -S "C:\Repos\mongo-c-driver-1.23.0" -B "C:\Repos\mongo-c-driver-1.23.0\cmake-build"
```

![Setting up MongoDB C driver build via CMake and Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/setting_up_mongodb_0ac90dc0aa.png)

Note: Build setup can be done with the CMake GUI application, as well.
* Execute build
    * Visual Studio’s default build type is Debug. A release build with debug info is recommended for production use.
    * Run the below command to build and install the driver

```
cmake --build . --config RelWithDebInfo --target install
```

![Building MongoDB C driver via CMake and Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/building_mongodb_c_driver_229ac4305d.png)

* You should now see libmongoc and libbson installed in *C:/Program Files/mongo-c-driver*.

![Building MongoDB C driver via CMake and Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/building_driver_via_cmake_125384ad15.png)

* Move the *mongo-c-driver* to *C:/* for convenience. Hence, C Driver should now be present at *C:/mongo-c-driver*.

### Step 2: Install C++ Driver

* Download C++ Driver
    * Download release tarball — [Releases · mongodb/mongo-cxx-driver](https://github.com/mongodb/mongo-cxx-driver/releases) — and extract it to *C:\Repos\mongo-cxx-driver-r3.7.0*.
* Set up build via CMake
    * Launch powershell/terminal as an administrator.
    * Navigate to *C:\Repos\mongo-cxx-driver-r3.7.0\build*.
    * Run the below command to generate and configure build files via CMake.

```
cmake .. -G "Visual Studio 17 2022" -A x64 -DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_FLAGS="/Zc:__cplusplus /EHsc" -DCMAKE_PREFIX_PATH=C:\mongo-c-driver -DCMAKE_INSTALL_PREFIX=C:\mongo-cxx-driver
```

![Setting up MongoDB C++ driver build via CMake and Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/setting_up_mongodb_driver_81d2b9aa2d.png)

Note: Setting *DCMAKE_CXX_FLAGS* should not be required for C++ driver version 3.7.1 and above.

* Execute build
    * Run the below command to build and install the driver
    
```
cmake --build . --config RelWithDebInfo --target install
```

* You should now see C++ driver installed in *C:\mongo-cxx-driver*.

## Visual Studio: Setting up the dev environment

* Create a new project in Visual Studio.
* Select *Console App* in the templates.

![New project options in Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/create_new_project_7c956cf247.png)

* Visual Studio should create a new project and open a .cpp file which prints “Hello World.” Navigate to the Solution Explorer panel, right-click on the solution name (*MongoCXXGettingStarted*, in this case), and click Properties.

![Microsoft Visual Studio solution properties](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/solution_properties_af0de46243.png)

* Go to *Configuration Properties > C/C++ > General > Additional Include Directories* and add the include directories from the C and C++ driver installation folders, as shown below.

![Microsoft Visual Studio include directories](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/include_directories_da1b8bf333.png)

* Go to *Configuration Properties > C/C++ > Language* and change the *C++ Language Standard* to C++17.

![Microsoft Visual Studio C++ language standard](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/language_standard_7bceb02aac.png)

* Go to *Configuration Properties > C/C++ > Command Line* and add */Zc:\_\_cplusplus* in the *Additional Options* field. This flag is needed to opt into the [correct definition of \_\_cplusplus](https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/).
* Go to *Configuration Properties > Linker > Input* and add the driver libs in *Additional Dependencies* section, as shown below.

![Microsoft Visual Studio linker dependencies](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/linker_dependencies_26269dcc28.png)

* Go to *Configuration Properties > Debugging > Environment* to add a path to the driver executables, as shown below.

![Microsoft Visual Studio debugging environment](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/debugging_environment_6de4cc98b8.png)

## Building the console application

> Source available [here](https://github.com/mongodb-developer/get-started-cxx/blob/main/student-records-console-app/studentRecordsConsoleApp.cpp)

Let’s build an application that maintains student records. We will input student data from the user, save them in the database, and perform different CRUD operations on the database.

### Connecting to the database

Let’s start with a simple program to connect to the MongoDB Atlas cluster and access the databases. [Get the connection string](https://www.mongodb.com/docs/guides/atlas/connection-string/) (URI) to the cluster and create a new environment variable with key as *“MONGODB\_URI”* and value as the connection string (URI). It’s a good practice to keep the connection string decoupled from the code.

Tip: Restart your machine after creating the environment variable in case the *“getEnvironmentVariable”* function fails to retrieve the environment variable.

```
#include <mongocxx/client.hpp>
#include <bsoncxx/builder/stream/document.hpp>
#include <bsoncxx/json.hpp>
#include <mongocxx/uri.hpp>
#include <mongocxx/instance.hpp>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
std::string getEnvironmentVariable(std::string environmentVarKey)
{
	char* pBuffer = nullptr;
	size_t size = 0;
	auto key = environmentVarKey.c_str();
	// Use the secure version of getenv, ie. _dupenv_s to fetch environment variable.
	if (_dupenv_s(&pBuffer, &size, key) == 0 && pBuffer != nullptr)
	{
		std::string environmentVarValue(pBuffer);
		free(pBuffer);
		return environmentVarValue;
	}
	else
	{
		return "";
	}
}
auto mongoURIStr = getEnvironmentVariable("MONGODB_URI");
static const mongocxx::uri mongoURI = mongocxx::uri{ mongoURIStr };
// Get all the databases from a given client.
vector<string> getDatabases(mongocxx::client& client)
{
	return client.list_database_names();
}
int main()
{
    // Create an instance.
    mongocxx::instance inst{};
    mongocxx::options::client client_options;
    auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
    client_options.server_api_opts(api);
    mongocxx::client conn{ mongoURI, client_options}
     auto dbs = getDatabases(conn);
     for (auto db : dbs)
     {
         cout << db << endl;
      }
      return 0;
}
```

Click on “Launch Debugger” to launch the console application. The output should looks something like this:

![Microsoft Visual Studio debug console](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/debug_console_9e7e46dd0e.png)

### CRUD operations

> [Full tutorial](https://mongocxx.org/mongocxx-v3/tutorial/)

Since the database is successfully connected to our application, let’s write some helper functions to interact with the database, performing CRUD operations.

#### Create

```
// Create a new collection in the given database.
void createCollection(mongocxx::database& db, const string& collectionName)
{
	db.create_collection(collectionName);
}
// Create a document from the given key-value pairs.
bsoncxx::document::value createDocument(const vector<pair<string, string>>& keyValues)
{
	bsoncxx::builder::stream::document document{};
	for (auto& keyValue : keyValues)
	{
		document << keyValue.first << keyValue.second;
	}
	return document << bsoncxx::builder::stream::finalize;
}
// Insert a document into the given collection.
void insertDocument(mongocxx::collection& collection, const bsoncxx::document::value& document)
{
	collection.insert_one(document.view());
}
```

#### Read

```
// Print the contents of the given collection.
void printCollection(mongocxx::collection& collection)
{
	// Check if collection is empty.
	if (collection.count_documents({}) == 0)
	{
		cout << "Collection is empty." << endl;
		return;
	}
	auto cursor = collection.find({});
	for (auto&& doc : cursor)
	{
		cout << bsoncxx::to_json(doc) << endl;
	}
}
// Find the document with given key-value pair.
void findDocument(mongocxx::collection& collection, const string& key, const string& value)
{
	// Create the query filter
	auto filter = bsoncxx::builder::stream::document{} << key << value << bsoncxx::builder::stream::finalize;
	//Add query filter argument in find
	auto cursor = collection.find({ filter });
	for (auto&& doc : cursor)
	{
          cout << bsoncxx::to_json(doc) << endl;
	}
}
```

#### Update

```
// Update the document with given key-value pair.
void updateDocument(mongocxx::collection& collection, const string& key, const string& value, const string& newKey, const string& newValue)
{
	collection.update_one(bsoncxx::builder::stream::document{} << key << value << bsoncxx::builder::stream::finalize,
		bsoncxx::builder::stream::document{} << "$set" << bsoncxx::builder::stream::open_document << newKey << newValue << bsoncxx::builder::stream::close_document << bsoncxx::builder::stream::finalize);
}
```

#### Delete

```
// Delete a document from a given collection.
void deleteDocument(mongocxx::collection& collection, const bsoncxx::document::value& document)
{
	collection.delete_one(document.view());
}
```

### The main() function

With all the helper functions in place, let’s create a menu in the main function which we can use to interact with the application.

```
// ********************************************** I/O Methods **********************************************
// Input student record.
void inputStudentRecord(mongocxx::collection& collection)
{
	string name, rollNo, branch, year;
	cout << "Enter name: ";
	cin >> name;
	cout << "Enter roll number: ";
	cin >> rollNo;
	cout << "Enter branch: ";
	cin >> branch;
	cout << "Enter year: ";
	cin >> year;
	insertDocument(collection, createDocument({ {"name", name}, {"rollNo", rollNo}, {"branch", branch}, {"year", year} }));
}
// Update student record.
void updateStudentRecord(mongocxx::collection& collection)
{
	string rollNo, newBranch, newYear;
	cout << "Enter roll number: ";
	cin >> rollNo;
	cout << "Enter new branch: ";
	cin >> newBranch;
	cout << "Enter new year: ";
	cin >> newYear;
	updateDocument(collection, "rollNo", rollNo, "branch", newBranch);
	updateDocument(collection, "rollNo", rollNo, "year", newYear);
}
// Find student record.
void findStudentRecord(mongocxx::collection& collection)
{
	string rollNo;
	cout << "Enter roll number: ";
	cin >> rollNo;
	findDocument(collection, "rollNo", rollNo);
}
// Delete student record.
void deleteStudentRecord(mongocxx::collection& collection)
{
	string rollNo;
	cout << "Enter roll number: ";
	cin >> rollNo;
	deleteDocument(collection, createDocument({ {"rollNo", rollNo} }));
}
// Print student records.
void printStudentRecords(mongocxx::collection& collection)
{
	printCollection(collection);
}
// ********************************************** Main **********************************************
int main()
{
     if(mongoURI.to_string().empty())
    {
	cout << "URI is empty";
	return 0;
    }
    // Create an instance.
    mongocxx::instance inst{};
    mongocxx::options::client client_options;
    auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
    client_options.server_api_opts(api);
    mongocxx::client conn{ mongoURI, client_options};
	const string dbName = "StudentRecords";
	const string collName = "StudentCollection";
	auto dbs = getDatabases(conn);
	// Check if database already exists.
	if (!(std::find(dbs.begin(), dbs.end(), dbName) != dbs.end()))
	{
		// Create a new database & collection for students.
conn[dbName];
	}
	auto studentDB = conn.database(dbName);
	auto allCollections = studentDB.list_collection_names();
	// Check if collection already exists.
	if (!(std::find(allCollections.begin(), allCollections.end(), collName) != allCollections.end()))
	{
		createCollection(studentDB, collName);
	}
	auto studentCollection = studentDB.collection(collName);
	// Create a menu for user interaction
	 int choice = -1;
	 do while (choice != 0)
	 {
		 //system("cls");
		 cout << endl << "**************************************************************************************************************" << endl;
		 cout << "Enter 1 to input student record" << endl;
		 cout << "Enter 2 to update student record" << endl;
		 cout << "Enter 3 to find student record" << endl;
		 cout << "Enter 4 to delete student record" << endl;
		 cout << "Enter 5 to print all student records" << endl;
		 cout << "Enter 0 to exit" << endl;
		 cout << "Enter Choice : "; 
		 cin >> choice;
		 cout << endl;
		 switch (choice)
		 {
		 case 1:
			 inputStudentRecord(studentCollection);
			 break;
		 case 2:
			 updateStudentRecord(studentCollection);
			 break;
		 case 3:
			 findStudentRecord(studentCollection);
			 break;
		 case 4:
			 deleteStudentRecord(studentCollection);
			 break;
		 case 5:
			 printStudentRecords(studentCollection);
			 break;
		 case 0:
			 break;
		 default:
			 cout << "Invalid choice" << endl;
			 break;
		 }
	 } while (choice != 0);
	 return 0;
}
```

## Application in action

When this application is executed, you can manage the student records via the console interface. Here’s a demo:

:youtube[]{vid=JsHdysx8yyw}

You can also see the collection in Atlas reflecting any change made via the console application.

![Student Records collection in Atlas](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/student_records_collection_atlas_f120e465fe.png)

## Wrapping up
With this article, we covered installation of C/C++ driver and creating a console application in Visual Studio that connects to MongoDB Atlas to perform basic CRUD operations.

More information about the C++ driver is available at [MongoDB C++ Driver](https://www.mongodb.com/docs/drivers/cxx/). 

Utilize Microsoft Visual Studio to compile/install the MongoDB C/C++ drivers on Windows. Use these to create a console app that interacts with MongoDB data.

Getting Started With MongoDB and C++

After having sketched the plan in our first article, this is the first one where we start coding. In this hands-on article, you will understand how to write firmware for a Raspberry Pi Pico (RP2) board try that implements offering sensor data through Bluetooth Low Energy communication.

In this new article, we will be focusing on the client side of the Bluetooth Low Energy communication: the BLE central.

In modern applications, storing and retrieving binary files efficiently is a crucial requirement. MongoDB enables this with binary data type in the [BSON](https://www.mongodb.com/docs/manual/core/document/) which is a binary serialization format used to store documents in MongoDB. A BSON binary value is a byte array and has a subtype (like generic binary subtype, UUID, MD5, etc.) that indicates how to interpret the binary data. See [BSON Types — MongoDB Manual](https://www.mongodb.com/docs/manual/reference/bson-types/#binary-data) for more information.

In this tutorial, we will write a console application in C++, using the [MongoDB C++ driver](https://www.mongodb.com/docs/drivers/cxx/) to upload and download binary data. 

**Note**: 

- When using this method, remember that the BSON document size limit in MongoDB is 16 MB. If your binary files are larger than this limit, consider using [GridFS](https://www.mongodb.com/developer/products/mongodb/storing-large-objects-and-files/) for more efficient handling of large files. See [GridFS example in C++](https://github.com/mongodb/mongo-cxx-driver/blob/master/examples/mongocxx/gridfs.cpp) for reference.
- Developers often weigh the [trade-offs and strategies](https://alexmarquardt.com/2017/03/02/trade-offs-to-consider-when-storing-binary-data-in-mongodb/) when storing binary data in MongoDB. It's essential to ensure that you have also considered different strategies to optimize your data management approach.

## Prerequisites

1. [MongoDB Atlas account](https://www.mongodb.com/developer/products/atlas/free-atlas-cluster/) with a cluster created.
2. IDE (like Microsoft Visual Studio or Microsoft Visual Studio Code) setup with the MongoDB C and C++ Driver installed. Follow the instructions in [Getting Started with MongoDB and C++](https://www.mongodb.com/developer/products/mongodb/getting-started-mongodb-c/) to install MongoDB C/C++ drivers and set up the dev environment in Visual Studio. Installation instructions [for other platforms](https://mongocxx.org/mongocxx-v3/installation/) are available.
3. Compiler with C++17 support (for using `std::filesystem` operations).
4. Your machine’s IP address [whitelisted](https://www.mongodb.com/docs/guides/atlas/network-connections/). Note: You can add *0.0.0.0/0* as the IP address, which should allow access from any machine. This setting is not recommended for production use.

## Building the application

> Source code available [**here**](https://github.com/mongodb-developer/get-started-cxx/blob/main/file-manager/fileManager.cpp).

As part of the [different BSON types](https://mongocxx.org/mongocxx-v3/working-with-bson/#bson-types), the C++ driver provides the [b_binary struct](https://github.com/mongodb/mongo-cxx-driver/blob/master/src/bsoncxx/types.hpp#L222) that can be used for storing binary data value in a BSON document. See the [API reference](http://mongocxx.org/api/current/structbsoncxx_1_1types_1_1b__binary.html).

We start with defining the structure of our BSON document. We have defined three keys: `name`, `path`, and `data`. These contain the name of the file being uploaded, its full path from the disk, and the actual file data respectively. See a sample document below:

![Sample document with binary data.][1]

In the code, these are defined with a `#define` so that it’s easy to modify them from a single place.

### Helper functions

Let’s add a helper function, `upload`, which accepts a file path and a MongoDB collection as inputs. Its primary purpose is to upload the file to the specified MongoDB collection by converting the file into a BSON binary value and constructing a BSON document to represent the file's metadata and content. Here are the key steps within the `upload` function:

1. Open the file at the given path and get its size.
    1. The file's size is determined by moving the file pointer to the end of the file and then retrieving the current position, which corresponds to the file's size.
    2. The file pointer is then reset to the beginning of the file to read the content later.
2. Read File Content into a Buffer: A `std::vector<char>` buffer is created with a size equal to the file's size to hold the file's binary data.
3. Create the BSON binary value.
    1. To represent the file content as BSON binary value, the code creates a `bsoncxx::types::b_binary` object.
    2. The b_binary object includes the binary subtype (set to `bsoncxx::binary_sub_type::k_binary`), the file's size, and data.
4. Create a BSON document with three fields: `name`, `path`, and `data`.
5. Insert the document into the collection.

```cpp
#include <mongocxx/client.hpp>
#include <bsoncxx/builder/basic/document.hpp>
#include <mongocxx/uri.hpp>
#include <mongocxx/instance.hpp>

#include <iostream>
#include <fstream>
#include <vector>
#include <filesystem>

#define FILE_NAME "name"
#define FILE_PATH "path"
#define FILE_DATA "data"

using bsoncxx::builder::basic::kvp; 
using bsoncxx::builder::basic::make_document;

// Upload a file to the collection.
bool upload(const std::string& filePath, mongocxx::collection& collection)
{
    // Open the binary file
    std::ifstream file(filePath, std::ios::binary | std::ios::ate);
    if (!file) 
    {
        std::cout << "Failed to open the file: " << filePath << std::endl;
        return false;
    }

    // Get the file size.
    std::streamsize fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    // Read the file content into a buffer
    std::vector<char> buffer(fileSize);
    if (!file.read(buffer.data(), fileSize)) 
    {
        std::cout << "Failed to read the file: " << filePath << std::endl;
        return false;
    }

    // Create the binary object for bsoncxx.
    bsoncxx::types::b_binary data{bsoncxx::binary_sub_type::k_binary, static_cast<std::uint32_t>(fileSize), reinterpret_cast<const std::uint8_t*>(buffer.data())};

    // Create a document with the file name and file content.

    auto doc = make_document(
        kvp(FILE_NAME, std::filesystem::path(filePath).filename()),
        kvp(FILE_PATH, filePath),
        kvp(FILE_DATA, data));

    // Insert the document into the collection.
    collection.insert_one(doc.view());

    std::cout << "Upload successful for: " << filePath << std::endl;
    return true;
}
```

Let’s write a similar helper function to perform the download. The code below takes the file name, destination folder, and a MongoDB collection as inputs. This function searches for a file by its name in the specified MongoDB collection, extracts its binary data, and saves it to the specified destination folder. 

Here are the key steps within the `download` function:

1. Create a filter query to find the file.
2. Use the query to find the document in the collection.
3. Extract and save binary data — the binary data is accessed using `bsoncxx::document::view` and then retrieved from the document using `binaryDocView[FILE_DATA].get_binary()`.
4. Create a file in the destination folder and write the binary content into the file.

```cpp
// Download a file from a collection to a given folder.
bool download(const std::string& fileName, const std::string& destinationFolder, mongocxx::collection& collection)
{
    // Create a query to find the file by filename
    auto filter = make_document(kvp(FILE_NAME, fileName));

    // Find the document in the collection
    auto result = collection.find_one(filter.view());

    if (result) 
    {
        // Get the binary data from the document
        bsoncxx::document::view binaryDocView = result->view();
        auto binaryData = binaryDocView[FILE_DATA].get_binary();

        // Create a file to save the binary data
        std::ofstream file(destinationFolder + fileName, std::ios::binary);
        if (!file) 
        {
            std::cout << "Failed to create the file: " << fileName << " at " << destinationFolder << std::endl;
            return false;
        }

        // Write the binary data to the file
        file.write(reinterpret_cast<const char*>(binaryData.bytes), binaryData.size);

        std::cout << "Download successful for: " << fileName << " at " << destinationFolder << std::endl;
        return true;
    } 
    else 
    {
        std::cout << "File not found in the collection: " << fileName << std::endl;
        return false;
    }
}
```

### The main() function

With the helper functions in place to perform upload and download, let’s write the main function that will drive this application. Here are the key steps within the `main` function:

1. Connect to MongoDB: Establish a connection to MongoDB by creating a mongocxx::client instance.

2. Fetch the database (`fileStorage`) and collection (`files`) to store the files.

3. Upload all files found in the specified uploadFolder: Recursively iterate through the folder using `std::filesystem::recursive_directory_iterator`. For each file found, call the upload function to `upload` the file to the MongoDB collection.

4. Download specific files with known filenames (`fileName1` and `fileName2`) by calling `download` function to retrieve and save the files to the `downloadFolder`.

5. Similarly, download all files in the collection by calling `find({})` to get a cursor and iterate through each document in the collection, extracting the file name and then calling `download` function to download and save the file to the `downloadFolder`.

    Note: In a real-world situation, calling `find({})` should be done with some kind of filtering/pagination to avoid issues with memory consumption and performance.

Make sure to [get the connection string](https://www.mongodb.com/docs/guides/atlas/connection-string/) (URI), update it to `mongoURIStr`, and set the different path and filenames to the ones on your disk.

```cpp
int main()
{
    try
    {
        auto mongoURIStr = "<Insert MongoDB Connection String>";
        static const mongocxx::uri mongoURI = mongocxx::uri{ mongoURIStr };
        
        // Create an instance.
        mongocxx::instance inst{};
        
        mongocxx::options::client client_options;
        auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
        client_options.server_api_opts(api);
        mongocxx::client conn{ mongoURI, client_options};
        
        const std::string dbName = "fileStorage";
        const std::string collName = "files";
        
        auto fileStorageDB = conn.database(dbName);
        auto filesCollection = fileStorageDB.collection(collName);
        // Drop previous data.
        filesCollection.drop();

        // Upload all files in the upload folder.
        const std::string uploadFolder = "/Users/bishtr/repos/fileStorage/upload/";
        for (const auto & filePath : std::filesystem::directory_iterator(uploadFolder))
        {
            if(std::filesystem::is_directory(filePath))
                continue;

            if(!upload(filePath.path().string(), filesCollection))
            {
                std::cout << "Upload failed for: " << filePath.path().string() << std::endl;
            }
        }

        // Download files to the download folder.
        const std::string downloadFolder = "/Users/bishtr/repos/fileStorage/download/";
        
        // Search with specific filenames and download it.
        const std::string fileName1 = "image-15.jpg", fileName2 = "Hi Seed Shaker 120bpm On Accents.wav";
        for ( auto fileName : {fileName1, fileName2} )
        {
            if (!download(fileName, downloadFolder, filesCollection))
            {
                std::cout << "Download failed for: " << fileName << std::endl;
            } 
        }
        
        // Download all files in the collection.
        auto cursor = filesCollection.find({});
        for (auto&& doc : cursor) 
        {
            auto fileName = std::string(doc[FILE_NAME].get_string().value);
            if (!download(fileName, downloadFolder, filesCollection))
            {
                std::cout << "Download failed for: " << fileName << std::endl;
            } 
        }
    }
    catch(const std::exception& e)
    {
        std::cout << "Exception encountered: " << e.what() << std::endl;
    }

    return 0;
}
```

## Application in action

Before executing this application, add some files (like images or audios) under the `uploadFolder` directory. 

![Files to be uploaded from local disk to MongoDB.][2]

Execute the application and you’ll observe output like this, signifying that the files are successfully uploaded and downloaded.

![Application output showing successful uploads and downloads.][3]

You can see the collection in [Atlas](https://www.mongodb.com/docs/atlas/atlas-ui/databases/) or [MongoDB Compass](https://www.mongodb.com/products/compass) reflecting the files uploaded via the application.

![Collection with binary data in MongoDB Compass.][4]

You will observe the files getting downloaded into the specified `downloadFolder` directory.

![Files downloaded from MongoDB to local disk.][5]

## Conclusion

With this article, we covered storing and retrieving binary data from a MongoDB database, using the MongoDB C++ driver. MongoDB's robust capabilities, combined with the ease of use provided by the [C++ driver](https://www.mongodb.com/docs/drivers/cxx/), offer a powerful solution for handling file storage in C++ applications. We can't wait to see what you build next! Share your creation with the [community](https://www.mongodb.com/community/forums/) and let us know how it turned out!


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt24f4df95c9cee69a/6504c0fd9bcd1b134c1d0e4b/image1.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt7c530c1eb76f566c/6504c12df4133500cb89250f/image3.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt768d2c8c6308391e/6504c153b863d9672da79f4c/image5.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt8c199ec2272f2c4f/6504c169a8cf8b4b4a3e1787/image2.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt78bb48b832d91de2/6504c17fec9337ab51ec845e/image4.png

Learn how to store binary data to MongoDB using the C++ driver.

Storing Binary Data with MongoDB and C++

Rachelle Palmer

Product Lead, Developer Experience

## Creators
[Ashish Adhikari](https://www.linkedin.com/in/ashish-adhikari-1493a2169/),  [Awan Shrestha](https://www.linkedin.com/in/awanshrestha/), [Sabil Shrestha](https://www.linkedin.com/in/sabil-shrestha-6a350112a/) and [Sansrit Paudel](https://www.linkedin.com/in/sansrit-paudel-07747a163/) from Kathmandu University in Nepal contributed this project.

## About the project

EnSat (Originally, the project was started with the name "PicoSat," and changed later to "EnSat") is a miniature version of an Environmental Satellite which helps to record and analyze the environmental parameters such as altitude, pressure, temperature, humidity, and pollution level.
Access this project in Github[here](https://github.com/awanshrestha/picosat).


## Inspiration

I was always very interested in how things work. We had a television when I was young, and there were all these wires connected to the television. I was fascinated by how the tv worked and how this could show moving images. I always wondered about things like these as a child. I studied this, and now I’m in college learning more about it. For this project, I wanted to do something that included data transfer at a very low level.

My country is not so advanced technologically. But last year, Nepal’s first satellite was launched into space. That inspired me. I might not be able to do that same thing now, but I wanted to try something smaller, and I built a miniature satellite. And that’s how this project came to be. I was working on the software, and my friends were working on the hardware, and that’s how we collaborated.

:youtube[]{vid=1tP2LEQJyNU}

## Why MongoDB?

We had our Professor Dr. Gajendra Sharma supervising the project, but we were free to choose whatever we wanted. For the first time in this project, I used MongoDB; before that, I was not familiar with MongoDB. I was also not used to the GUI react part; while I was learning React, the course also included MongoDB. Before this project, I was using MySQL, I was planning on using MySQL again, but after following this course, I decided to switch to MongoDB. And this was good; transferring the data and storing the data is so much more comfortable with MongoDB. With MongoDB, we only have to fetch the data from the database and send it. The project is quite complicated, but MongoDB made it so much easier on the software level, so that’s why we chose MongoDB for the project.

## How it works

A satellite with a microcontroller and sensors transmits the environmental data to Ground Station through radio frequency using ISM band 2.4 GHz. The Ground Station has a microcontroller and receiver connected to a computer where the data is stored in the MongoDB database. The API then fetches data from the database providing live data and history data of the environmental parameters. Using the data from API, the information is shown in the GUI built in React. This was our group semester project where the Serialport package for data communication, MongoDB for database, and React was used for the GUI. Our report in the GitHub repository can also tell you more in detail how everything works.

It is a unique and different project, and it is our small effort to tackle the global issue of climate change and environmental pollution. The project includes both hardware and software parts. EnSat consists of multidisciplinary domains. Creating it was a huge learning opportunity for us as we made our own design and architecture for the project's hardware and software parts. This project can inspire many students to try MongoDB with skills from different domains and try something good for our world.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screenshot_3_c73bb1ef8e.png)

## Challenges and learnings

There was one challenging part, and I was stuck for three days. It made me build my own serial data port to be able to get data in the server. That was a difficult time. With MongoDB, there was not any difficulty. It made the job so much easier.

It’s also nice to share that we participated in three competitions and that we won three awards. One contest was where the satellite is actually dropped from the drone from the height, and we have to capture the environmental data at different heights as it comes down. It was the first competition of that kind in my country, and we won that one. We won another one for the best product and another for the best product under the Advancing Towards Smart Cities, Sustainable Development Goals category.

I learned so many things while working on this project. Not only React and MongoDB, but I also learned everything around the hardware: Arduino programming, programming C for Arduino, the hardware level of programming. And the most important thing I learned is never to give up. At times it was so frustrating and difficult to get everything running. If you want to do something, keep on trying, and sometimes it clicks in your mind, and you just do it, and it happens.

I’m glad that MongoDB is starting programs for Students. These are the kind of things that motivate us. Coming from a not so developed country, we sometimes feel a bit separated. It’s so amazing that we can actually take part in this kind of program. It’s the most motivating factor in doing engineering and studying engineering. Working on these complex projects and then being recognized by MongoDB is a great motivation for all of us.

An environmental satellite to get information about your environment.

EnSat

An extension of C and is widely used for search engines, gaming, and GUI-based applications. 

C++

Featured

Red Mosquitto: Implement a Noise Sensor With an MQTT Client in an ESP32

Me and the Devil BlueZ: Reading BLE Sensors From C++

CMake + Conan + VS Code

All C++ Content