# Using Open CV C++ with Azure IoT Edge

https://jaredrhodes.com/blog/using-open-cv-c-with-azure-iot-edge/

If you are looking for a guide on creating an Open CV module in Python, check out a guide [here](https://kevinsaye.wordpress.com/2018/04/16/creating-an-opencv-module-for-iot-edge/). This guide will focus on creating an [Azure IoT Edge](https://azure.microsoft.com/en-us/services/iot-edge/) module in C++. To accomplish this we need to take the following steps:

- [Create the Azure IoT Edge Module](#create-the-azure-iot-edge-module)
- [Create a working Open CV Build](#create-a-working-open-cv-build)
- [Deploy the Azure IoT Edge Module](#deploy-the-azure-iot-edge-module)

## Create the Azure IoT Edge Module

### Prerequisites

This article assumes that you use a computer or virtual machine running Windows or Linux as your development machine. And you simulate your IoT Edge device on your development machine.

#### Needs:

- [Visual Studio Code](https://code.visualstudio.com/)
- [Azure IoT Edge extension](https://marketplace.visualstudio.com/items?itemName=vsciot-vscode.azure-iot-edge)
- [C/C++ extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) for Visual Studio Code.
- [Docker extension](https://marketplace.visualstudio.com/items?itemName=PeterJausovec.vscode-docker)

To create a module, you need Docker to build the module image, and a container registry to hold the module image:

- [Docker Community Edition](https://docs.docker.com/install/) on your development machine.
- [Azure Container Registry](https://docs.microsoft.com/azure/container-registry/) or [Docker Hub](https://docs.docker.com/docker-hub/repos/#viewing-repository-tags)

### Create a new solution template

Take these steps to create an IoT Edge module based on Azure IoT C SDK using Visual Studio Code and the Azure IoT Edge extension. First you create a solution, and then you generate the first module in that solution. Each solution can contain more than one module.

1. In Visual Studio Code, select **View** > **Integrated Terminal**.
2. Select **View** > **Command Palette**.
3. In the command palette, enter and run the command **Azure IoT Edge: New IoT Edge Solution**.![Run New IoT Edge Solution](https://docs.microsoft.com/en-us/azure/iot-edge/media/how-to-develop-csharp-module/new-solution.png)
4. Browse to the folder where you want to create the new solution. Choose **Select folder**.
5. Enter a name for your solution.
6. Select **C Module** as the template for the first module in the solution.
7. Enter a name for your module. Choose a name that's unique within your container registry.
8. Provide the name of the module's image repository. VS Code autopopulates the module name with **localhost:5000**. Replace it with your own registry information. If you use a local Docker registry for testing, then **localhost** is fine. If you use Azure Container Registry, then use the login server from your registry's settings. The login server looks like **<registry name>.azurecr.io**.

VS Code takes the information you provided, creates an IoT Edge solution, and then loads it in a new window.

![View IoT Edge solution](https://docs.microsoft.com/en-us/azure/iot-edge/media/how-to-develop-c-module/view-solution.png){: loading="lazy" }

There are four items within the solution:

- A **.vscode** folder contains debug configurations.
- A **modules** folder has subfolders for each module. At this point, you only have one. But you can add more in the command palette with the command **Azure IoT Edge: Add IoT Edge Module**.
- An **.env** file lists your environment variables. If Azure Container Registry is your registry, you'll have an Azure Container Registry username and password in it.
Note

    The environment file is only created if you provide an image repository for the module. If you accepted the localhost defaults to test and debug locally, then you don't need to declare environment variables.

- A **deployment.template.json** file lists your new module along with a sample **tempSensor** module that simulates data you can use for testing. For more information about how deployment manifests work, see [Learn how to use deployment manifests to deploy modules and establish routes](https://docs.microsoft.com/en-us/azure/iot-edge/module-composition).

### Develop your module

The default C module code that comes with the solution is located at **modules** > > **main.c**. The module and the deployment.template.json file are set up so that you can build the solution, push it to your container registry, and deploy it to a device to start testing without touching any code. The module is built to simply take input from a source (in this case, the tempSensor module that simulates data) and pipe it to IoT Hub.

When you're ready to customize the C template with your own code, use the [Azure IoT Hub SDKs](https://docs.microsoft.com/en-us/azure/iot-hub/iot-hub-devguide-sdks) to build modules that address the key needs for IoT solutions such as security, device management, and reliability.

### Build and deploy your module for debugging

In each module folder, there are several Docker files for different container types. Use any of these files that end with the extension **.debug** to build your module for testing. Currently, C modules support debugging only in Linux amd64 containers.

1. In VS Code, navigate to the `deployment.template.json` file. Update your module image URL by adding **.debug** to the end.![Add **.debug** to your image name](https://docs.microsoft.com/en-us/azure/iot-edge/media/how-to-develop-c-module/image-debug.png){: loading="lazy" }
2. Replace the C module createOptions in **deployment.template.json** with below content and save this file:

    ```
    "createOptions": "{\"HostConfig\": {\"Privileged\": true}}"

    ```

3. In the VS Code command palette, enter and run the command **Edge: Build IoT Edge solution**.
4. Select the `deployment.template.json` file for your solution from the command palette.
5. In Azure IoT Hub Device Explorer, right-click an IoT Edge device ID. Then select **Create deployment for IoT Edge device**.
6. Open your solution's **config** folder. Then select the `deployment.json` file. Choose **Select Edge Deployment Manifest**.

You'll see the deployment successfully created with a deployment ID in a VS Code-integrated terminal.

Check your container status in the VS Code Docker explorer or by running the `docker ps` command in the terminal.

### Start debugging C module in VS Code

VS Code keeps debugging configuration information in a `launch.json` file located in a `.vscode` folder in your workspace. This `launch.json` file was generated when you created a new IoT Edge solution. It updates each time you add a new module that supports debugging.

1. Navigate to the VS Code debug view. Select the debug configuration file for your module. The debug option name should be similar to **ModuleName Remote Debug (C)**![Select debug configuration](https://docs.microsoft.com/en-us/azure/iot-edge/media/how-to-develop-c-module/debug-config.png).
2. Navigate to `main.c`. Add a breakpoint in this file.
3. Select **Start Debugging** or select **F5**. Select the process to attach to.
4. In VS Code Debug view, you'll see the variables in the left panel.

The preceding example shows how to debug C IoT Edge modules on containers. It added exposed ports in your module container createOptions. After you finish debugging your C modules, we recommend you remove these exposed ports for production-ready IoT Edge modules.

## Create a working Open CV Build

The working environment is an [Ubuntu 18.04 64 bit Desktop OS](https://www.ubuntu.com/desktop) running [Clion](https://www.jetbrains.com/clion/) using an embedded version of [CMake 3.10](https://cmake.org/). [Open CV](https://opencv.org/) is added via [source](https://github.com/opencv/opencv) as a submodule to the project and added as a package in the CMakeLists.txt with the following line:

`FIND_PACKAGE (OpenCV REQUIRED)`

Once that was added to the CMakeLists.txt, the main.cpp file was changed to the following code:

https://gist.github.com/QiMata/9e05b89e8edf462cb9769e32326020c1

## Deploy the Azure IoT Edge Module

Once you create IoT Edge modules with your business logic, you want to deploy them to your devices to operate at the edge. If you have multiple modules that work together to collect and process data, you can deploy them all at once and declare the routing rules that connect them.

This article shows how to create a JSON deployment manifest, then use that file to push the deployment to an IoT Edge device. For information about creating a deployment that targets multiple devices based on their shared tags, see [Deploy and monitor IoT Edge modules at scale](https://docs.microsoft.com/en-us/azure/iot-edge/how-to-deploy-monitor)

### Prerequisites

- An [IoT hub](https://docs.microsoft.com/en-us/azure/iot-hub/iot-hub-create-through-portal) in your Azure subscription.
- An [IoT Edge device](https://docs.microsoft.com/en-us/azure/iot-edge/how-to-register-device-portal) with the IoT Edge runtime installed.
- [Visual Studio Code](https://code.visualstudio.com/).
- [Azure IoT Edge extension](https://marketplace.visualstudio.com/items?itemName=vsciot-vscode.azure-iot-edge) for Visual Studio Code.

### Configure a deployment manifest

A deployment manifest is a JSON document that describes which modules to deploy, how data flows between the modules, and desired properties of the module twins. For more information about how deployment manifests work and how to create them, see [Understand how IoT Edge modules can be used, configured, and reused](https://docs.microsoft.com/en-us/azure/iot-edge/module-composition).

To deploy modules using Visual Studio Code, save the deployment manifest locally as a .JSON file. You will use the file path in the next section when you run the command to apply the configuration to your device.

Here's a basic deployment manifest with one module as an example:

```
{
  "modulesContent": {
    "$edgeAgent": {
      "properties.desired": {
        "schemaVersion": "1.0",
        "runtime": {
          "type": "docker",
          "settings": {
            "minDockerVersion": "v1.25",
            "loggingOptions": "",
            "registryCredentials": {}
          }
        },
        "systemModules": {
          "edgeAgent": {
            "type": "docker",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-agent:1.0",
              "createOptions": "{}"
            }
          },
          "edgeHub": {
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-hub:1.0",
              "createOptions": "{}"
            }
          }
        },
        "modules": {
          "tempSensor": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-simulated-temperature-sensor:1.0",
              "createOptions": "{}"
            }
          }
        }
      }
    },
    "$edgeHub": {
      "properties.desired": {
        "schemaVersion": "1.0",
        "routes": {
            "route": "FROM /* INTO $upstream"
        },
        "storeAndForwardConfiguration": {
          "timeToLiveSecs": 7200
        }
      }
    },
    "tempSensor": {
      "properties.desired": {}
    }
  }
}

```

### Sign in to access your IoT hub

You can use the Azure IoT extensions for Visual Studio Code to perform operations with your IoT hub. For these operations to work, you need to sign in to your Azure account and select the IoT hub that you are working on.

1. In Visual Studio Code, open the **Explorer** view.
2. At the bottom of the Explorer, expand the **Azure IoT Hub Devices** section.![Expand Azure IoT Hub Devices](https://docs.microsoft.com/en-us/azure/iot-edge/media/how-to-deploy-modules-vscode/azure-iot-hub-devices.png)
3. Click on the **...** in the **Azure IoT Hub Devices** section header. If you don't see the ellipsis, hover over the header.
4. Choose **Select IoT Hub**.
5. If you are not signed in to your Azure account, follow the prompts to do so.
6. Select your Azure subscription.
7. Select your IoT hub.

### Deploy to your device

You deploy modules to your device by applying the deployment manifest that you configured with the module information.

1. In the Visual Studio Code explorer view, expand the **Azure IoT Hub Devices** section.
2. Right-click on the device that you want to configure with the deployment manifest.
3. Select **Create Deployment for IoT Edge Device**.
4. Navigate to the deployment manifest JSON file that you want to use, and click **Select Edge Deployment Manifest**.![Select Edge Deployment Manifest](https://docs.microsoft.com/en-us/azure/iot-edge/media/how-to-deploy-modules-vscode/select-deployment-manifest.png)

The results of your deployment are printed in the VS Code output. Successful deployments are applied within a few minutes if the target device is running and connected to the internet.

### View modules on your device

Once you've deployed modules to your device, you can view all of them in the **Azure IoT Hub Devices** section. Select the arrow next to your IoT Edge device to expand it. All the currently running modules are displayed.

If you recently deployed new modules to a device, hover over the **Azure IoT Hub Devices** section header and select the refresh icon to update the view.

Right-click the name of a module to view and edit the module twin.