Some Background
Setting Up the Cloud Services
Configure Azure Sphere Device
BME680 Sensor Overview
BME680 Configuration
Reading BME680 Data
Water Detect Sensor Setup
Communication Between Azure Sphere and Cloud
Reading Data
Sending Sensor Data
What’s Possible

Published July 30, 2019 © GPL3+

Azure Sphere Weather Station

Use the Azure Sphere Starter Kit and two click boards to monitor current weather conditions and send the data to the Azure Cloud.

IntermediateFull instructions provided4 hours6,881

Hackster Impact Prize

Secure Everything with Azure Sphere

Things used in this project

Hardware components

Avnet Azure Sphere MT3620 Starter Kit

MIKROE Environmental Click Board

MIKROE UV-4 Click Board

MIKROE Water Detect click

Software apps and online services

Microsoft Visual Studio 2017

Story

Some Background

In one of my previous projects, I showcased how to read data from the onboard LSM6DSO gyroscope/accelerometer. It covered the basics of how to use the Azure Sphere’s I2C bus, read from a datasheet, and write to registers at a low level. In this project, I will demonstrate how to use two click boards to create a mini weather station and send that data to the cloud.

If you have just received your Azure Sphere device, make sure to follow this getting started guide in order to get it set up first, or else all of the steps below will fail to work.

Setting Up the Cloud Services

To begin, the Azure Sphere device must be connected to the Azure Cloud. In order to facilitate communication, an Azure IoT Hub service is set up in the Azure Cloud Console. First, log into the Azure Portal and click Create a resource in the top left. Then search and select IoT Hub to create it.

After filling in the necessary fields, such as the resource group and name, select the pricing tier and scale on the Size and Scale section.

Lastly, go to Review + Create and click Create to create the new IoT Hub service. Make sure to wait a couple of minutes for it to finish deploying.

Next, an IoT Hub Device Provisioning Service must be created to register the Azure Sphere device. Click on Create a resource and search for Device provisioning service. After selecting it, click Create after entering in the relevant information.

Once the resource has been deployed, click on the notification and select Pin to dashboard and then Go to resource.

In order to link the Azure Sphere device to the service, select Linked IoT Hubs and click the +Add button. Then, choose which IoT hub to use, and set the Access Policy to iothubowner. After saving, refresh the Linked IoT Hubs section to see your new link.

Configure Azure Sphere Device

Now that the two IoT services are linked, it’s time to let the Azure Cloud know that your device exists and is ready to communicate. First, open up the Azure Sphere Developer Command Prompt and login with azsphere login. Then, download a Certificate Authority (CA) with azsphere tenant download-CA-certificate –output CAcertificate.cer. This creates a.cer file in the current active directory (usually Documents).

Next, navigate to the Device Provisioning Service in the Azure Portal and click on the Certificates tab on the left. Click Add and name the certificate, as well as upload the.cer that was created earlier.

The Certificate Explorer list should now show the certificate as Unverified. Click on it and view the Certificate Details. Copy the generated Verification Code to your clipboard. In the Azure Sphere Developer Command Prompt, type in the command azsphere tenant download-validation-certificate --output ValidationCertification.cer --verificationcode <code> where <code> is that verification code from the clipboard. This generates a new.cer file, which can then be uploaded to the Verification Certificate section, just underneath the Verification Code section.

Now select Manage Enrollments and click Add enrollment group. Type in a name and then choose the certificate and assign an IoT Hub. Finally, click Save.

And that’s it! Now any device in registered to the tenant will be automatically added when it first connects.

BME680 Sensor Overview

MikroE’s Environmental Click Board has a BME680 sensor at its heart.

It is able to detect temperature, humidity, pressure, and even volatile organic compounds (VOCs), such as CO2. Bosch provides a basic API, but it doesn’t play nicely with the Azure Sphere’s I2C functions, so reading from the datasheet and writing to registers directly is necessary.

BME680 Configuration

Thankfully, the BME680 is an easy sensor to configure and read from. I began by creating a file that defines each necessary register’s address, such as control and data.

Reading and writing to registers via I2C on the Azure Sphere is handled differently than on an Arduino board. First, an I2C interface must be opened. This is done by adding I2cMaster : [“ISU2”], to the application_manifest.json file under the capabilities section.

In order to write data to a register, a pointer to an array must be passed to the I2CMaster_Write() function. I accomplished this by creating several arrays that contain both the target address and data. For instance, in order to configure the sensor to use 1x oversampling, a value of 0x01 gets written to address 0x72.

In order to read gas data, the internal heater must first be configured. This is done through a series of calculations that determine the resistance. I created a function in main.c called calculate_heat() that returns an 8-bit value for the resistance.

There are several constants that need to be retrieved before anything else can be done.

I first initialized several variables to store temporary values retrieved from the registers. Next, I initialized another variable called current_reg which stores the current register being written to / read from. To read data from registers, I called I2CMaster_WriteThenRead(), which retrieves a value from a register and stores it in the variable passed to it. The datasheet outlines the calculations to perform.

Reading BME680 Data

Now that everything had been set up for the BME680, it was time to take some readings. The first to be read is the temperature. This is done by creating several variables for both temporary register data and more permanent data. Each time a value is read from a register, the returned value is stored and the current_reg value is set to the next register. Since the registers can only store 8-bits each, some data is split among several registers. It is then necessary to read each value into its own variable and combine them into a single value.

Bit-level manipulation is done by taking the Most Significant Bit (MSB) value and shifting it to the left by 8 bits (operation << 8) and then adding it to the LSB value. Although the temperature can be read as-is, it is best to perform some calculations to create a compensated value. Here the datasheet outlines how to do that:

The humidity, pressure, and gas are all read and calculated in a way almost identical to how the temperature is calculated. Here is a register map and some screenshots of each function.

Water Detect Sensor Setup

The water detector click board is quite simple in comparison to the BME680.

It is comprised of an op-amp that sets a pin high when water is detected. On the Avnet Azure Sphere Starter Kit, this pin connects to GPIO pin 2. In order to use any GPIO pin, it must be added to the app_manifest.json file by placing its number into the GPIO line. Next, the pin is set as an input with GPIO_OpenAsInput(2). This allows the pin’s value to be read.

Communication Between Azure Sphere and Cloud

To begin, a poll period of ten seconds is set, which means the device checks the cloud for new data every ten seconds. Next, it checks if there is a suitable network connection, and if so, it creates a new client with the given scope ID.

In order to see what data has been received by the cloud, a cloud function needs to be created. This takes the output from the IoT Hub service and pipes it into a console. I first went to the Azure Cloud Portal and selected Function App to bring up the Function list page. Then I clicked Add and entered the name, pricing tier, and storage. After I had created the function app, I created a new function and selected the IoT Hub template.

This allows any data from the hub to be transmitted to the function. To view the data, I edited the index.js file to:

Reading Data

Events get scheduled by using a library called epoll. It allows for the easy creation of events that get triggered repeatedly at regular intervals. For this project, 4 are needed: one for the epoll itself, one to poll for new data from the cloud, one to send data to the cloud, and finally, one to check for the presence of water. It is extremely easy to assign a variable with the double datatype to what the get_sensor_data functions return.

Sending Sensor Data

In the function SendData, the temperature, humidity, pressure, and gas values are all read, along with whether or not there is water present on the sensor. All of those values get sent to the cloud in JSON format.

Here is some example output:

What’s Possible?

In the near future, I am planning to create a project that displays this data in real-time via a local dashboard. A separate IoT device could then check if the conditions are getting too hot or dry and water the plants accordingly. It could also send out alerts if it senses there are too many VOCs in the air, which could indicate a possible respiratory hazard.

Code

#include <signal.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <errno.h>

#define I2C_STRUCTS_VERSION 1

#include <applibs/log.h>
#include <applibs/gpio.h>
#include <applibs/i2c.h>
#include <applibs/networking.h>
#include <applibs/storage.h>

#include "epoll_timerfd_utilities.h"

#include "BME680_reg.h"

#include <azureiot/iothub_device_client_ll.h>
#include <azureiot/iothub_client_core_common.h>
#include <azureiot/iothub_client_options.h>
#include <azureiot/iothub.h>
#include <azureiot/iothubtransportmqtt.h>
#include <azureiot/azure_sphere_provisioning.h>
#include "epoll_timerfd_utilities.h"

#define SCOPEID_LENGTH 20
static char scopeId[SCOPEID_LENGTH]; // ScopeId for the Azure IoT Central application, set in
									 // app_manifest.json, CmdArgs

static volatile sig_atomic_t terminationRequired = false;

static I2C_DeviceAddress bme680_addr = 0x77;

static IOTHUB_DEVICE_CLIENT_LL_HANDLE iothubClientHandle = NULL;
static const int keepalivePeriodSeconds = 20;
static bool iothubAuthenticated = false;
static void SendMessageCallback(IOTHUB_CLIENT_CONFIRMATION_RESULT result, void* context);
static void TwinCallback(DEVICE_TWIN_UPDATE_STATE updateState, const unsigned char* payload,
	size_t payloadSize, void* userContextCallback);
static void TwinReportBoolState(const char* propertyName, bool propertyValue);
static void ReportStatusCallback(int result, void* context);
static void readWaterDetectHandler(EventData* eventData);
static const char* GetReasonString(IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason);
static const char* getAzureSphereProvisioningResultString(
	AZURE_SPHERE_PROV_RETURN_VALUE provisioningResult);
static void SendTelemetry(const unsigned char* key, const unsigned char* key1, const unsigned char* value1,
	const unsigned char* key2, const unsigned char* value2,
	const unsigned char* key3, const unsigned char* value3,
	const unsigned char* key4, const unsigned char* value4,
	const unsigned char* key5, const unsigned char* value5);
static void SetupAzureClient(void);

static uint8_t calculate_heat(void);
static double get_temperature(void);
static double get_humidity(void);
static double get_pressure(void);
static double get_gas(void);

static void init_device(void);

static void SendData(void);

static int InitPeripheralsAndHandlers(void);
static void ClosePeripheralsAndHandlers(void);

static int azureTimerFd = -1;
static int epollFd = -1;
static int i2cFd = -1;
static int waterDetectGpioFd = -1;
static int waterDetectTimerFd = -1;

static GPIO_Value_Type waterDetectState = GPIO_Value_Low;

static const int AzureIoTDefaultPollPeriodSeconds = 10;
static const int AzureIoTMinReconnectPeriodSeconds = 60;
static const int AzureIoTMaxReconnectPeriodSeconds = 10 * 60;
static const int waterDetectPollPeriod = 5000000000;

static int azureIoTPollPeriodSeconds = -1;

static void AzureTimerEventHandler(EventData* eventData);

static void TerminationHandler(int signalNumber)
{
	// Don't use Log_Debug here, as it is not guaranteed to be async-signal-safe.
	terminationRequired = true;
}

int main(int argc, char* argv[])
{
	Log_Debug("IoT Hub/Central Application starting.\n");

	if (argc == 2) {
		Log_Debug("Setting Azure Scope ID %s\n", argv[1]);
		strncpy(scopeId, argv[1], SCOPEID_LENGTH);
	}
	else {
		Log_Debug("ScopeId needs to be set in the app_manifest CmdArgs\n");
		return -1;
	}

	if (InitPeripheralsAndHandlers() != 0) {
		terminationRequired = true;
	}

	// Main loop
	while (!terminationRequired) {
		if (WaitForEventAndCallHandler(epollFd) != 0) {
			terminationRequired = true;
		}
	}

	ClosePeripheralsAndHandlers();

	Log_Debug("Application exiting.\n");

	return 0;
}

/// <summary>
/// Azure timer event:  Check connection status and send telemetry
/// </summary>
static void AzureTimerEventHandler(EventData* eventData)
{
	if (ConsumeTimerFdEvent(azureTimerFd) != 0) {
		terminationRequired = true;
		return;
	}

	bool isNetworkReady = false;
	if (Networking_IsNetworkingReady(&isNetworkReady) != -1) {
		if (isNetworkReady && !iothubAuthenticated) {
			SetupAzureClient();
		}
	}
	else {
		Log_Debug("Failed to get Network state\n");
	}

	if (iothubAuthenticated) {
		SendData();
		IoTHubDeviceClient_LL_DoWork(iothubClientHandle);
	}
}

static EventData azureEventData = { .eventHandler = &AzureTimerEventHandler };
static EventData waterDetectEventData = { .eventHandler = &readWaterDetectHandler };

static int InitPeripheralsAndHandlers(void)
{
	struct sigaction action;
	memset(&action, 0, sizeof(struct sigaction));
	action.sa_handler = TerminationHandler;
	sigaction(SIGTERM, &action, NULL);

	epollFd = CreateEpollFd();
	if (epollFd < 0) {
		return -1;
	}

	Log_Debug("Opening ISU2 I2C\n");
	i2cFd = I2CMaster_Open(2);
	I2CMaster_SetBusSpeed(i2cFd, I2C_BUS_SPEED_STANDARD);
	I2CMaster_SetTimeout(i2cFd, 100);
	I2CMaster_SetDefaultTargetAddress(i2cFd, bme680_addr);

	init_device();

	azureIoTPollPeriodSeconds = AzureIoTDefaultPollPeriodSeconds;
	struct timespec azureTelemetryPeriod = { azureIoTPollPeriodSeconds, 0 };
	azureTimerFd =
		CreateTimerFdAndAddToEpoll(epollFd, &azureTelemetryPeriod, &azureEventData, EPOLLIN);

	Log_Debug("Opening GPIO2 as input.\n");
	waterDetectGpioFd = GPIO_OpenAsInput(2);
	if (waterDetectGpioFd < 0) {
		Log_Debug("ERROR: Could not open button GPIO: %s (%d).\n", strerror(errno), errno);
		return -1;
	}

	struct timespec waterDetectCheckPeriod = { 0, waterDetectPollPeriod };
	waterDetectTimerFd = CreateTimerFdAndAddToEpoll(epollFd, &waterDetectCheckPeriod, &waterDetectEventData, EPOLLIN);
	if (waterDetectTimerFd < 0) return -1;

	return 0;
}

static void readWaterDetectHandler(EventData *eventData)
{
	GPIO_Value_Type newState;
	int result = GPIO_GetValue(waterDetectGpioFd, &newState);
	if (result != 0) {
		Log_Debug("ERROR: Could not read button GPIO: %s (%d).\n", strerror(errno), errno);
		//terminationRequired = true;
		return;
	}
	waterDetectState = newState;
}

static void init_device(void) {
	I2CMaster_Write(i2cFd, bme680_addr, ctrl_hum_data, sizeof(ctrl_hum_data));
	I2CMaster_Write(i2cFd, bme680_addr, ctrl_meas_data, sizeof(ctrl_meas_data));
	I2CMaster_Write(i2cFd, bme680_addr, ctrl_gas_1_data, sizeof(ctrl_gas_1_data));
	I2CMaster_Write(i2cFd, bme680_addr, gas_wait_0_data, sizeof(gas_wait_0_data));
	res_heat_0_data[1] = calculate_heat();
	I2CMaster_Write(i2cFd, bme680_addr, res_heat_0_data, sizeof(res_heat_0_data));
	I2CMaster_Write(i2cFd, bme680_addr, config_data, sizeof(config_data));
}

static uint8_t calculate_heat(void) 
{
	int par_g1, par_g2, par_g2_temp, par_g3, res_heat_range, res_heat_val;
	uint8_t current_reg = 0xED;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_g1, 1);
	current_reg = 0xEB;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_g2_temp, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_g2, 1);
	current_reg = 0xEE;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_g3, 1);
	current_reg = 0x02;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &res_heat_range, 1);
	current_reg = 0x00;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &res_heat_val, 1);

	par_g2 = (par_g2 << 8) + par_g2_temp;
	res_heat_range &= 0b00110000;

	double var1 = ((double)par_g1 / 16.0) + 49.0;
	double var2 = (((double)par_g2 / 32768.0) * 0.0005) + 0.00235;
	double var3 = (double)par_g3 / 1024.0;
	double var4 = var1 * (1.0 + (var2 * (double)300.0));
	double var5 = var4 + (var3 * (double)23.0);
	return (uint8_t)(3.4 * ((var5 * (4.0 / (4.0 + (double)res_heat_range)) *
		(1.0 / (1.0 + ((double)res_heat_val * 0.002)))) - 25));
}

static void ClosePeripheralsAndHandlers(void)
{
	Log_Debug("Closing file descriptors\n");

	CloseFdAndPrintError(i2cFd, "I2C");
	CloseFdAndPrintError(azureTimerFd, "AzureTimer");
	CloseFdAndPrintError(epollFd, "Epoll");
	CloseFdAndPrintError(waterDetectGpioFd, "WaterDetectGpio");
	CloseFdAndPrintError(waterDetectTimerFd, "WaterDetectTimer");
}

static void HubConnectionStatusCallback(IOTHUB_CLIENT_CONNECTION_STATUS result,
	IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason,
	void* userContextCallback)
{
	iothubAuthenticated = (result == IOTHUB_CLIENT_CONNECTION_AUTHENTICATED);
	Log_Debug("IoT Hub Authenticated: %s\n", GetReasonString(reason));
}

static void SetupAzureClient(void)
{
	if (iothubClientHandle != NULL)
		IoTHubDeviceClient_LL_Destroy(iothubClientHandle);

	AZURE_SPHERE_PROV_RETURN_VALUE provResult =
		IoTHubDeviceClient_LL_CreateWithAzureSphereDeviceAuthProvisioning(scopeId, 10000,
			&iothubClientHandle);
	Log_Debug("IoTHubDeviceClient_LL_CreateWithAzureSphereDeviceAuthProvisioning returned '%s'.\n",
		getAzureSphereProvisioningResultString(provResult));

	if (provResult.result != AZURE_SPHERE_PROV_RESULT_OK) {

		// If we fail to connect, reduce the polling frequency, starting at
		// AzureIoTMinReconnectPeriodSeconds and with a backoff up to
		// AzureIoTMaxReconnectPeriodSeconds
		if (azureIoTPollPeriodSeconds == AzureIoTDefaultPollPeriodSeconds) {
			azureIoTPollPeriodSeconds = AzureIoTMinReconnectPeriodSeconds;
		}
		else {
			azureIoTPollPeriodSeconds *= 2;
			if (azureIoTPollPeriodSeconds > AzureIoTMaxReconnectPeriodSeconds) {
				azureIoTPollPeriodSeconds = AzureIoTMaxReconnectPeriodSeconds;
			}
		}

		struct timespec azureTelemetryPeriod = { azureIoTPollPeriodSeconds, 0 };
		SetTimerFdToPeriod(azureTimerFd, &azureTelemetryPeriod);

		Log_Debug("ERROR: failure to create IoTHub Handle - will retry in %i seconds.\n",
			azureIoTPollPeriodSeconds);
		return;
	}

	// Successfully connected, so make sure the polling frequency is back to the default
	azureIoTPollPeriodSeconds = AzureIoTDefaultPollPeriodSeconds;
	struct timespec azureTelemetryPeriod = { azureIoTPollPeriodSeconds, 0 };
	SetTimerFdToPeriod(azureTimerFd, &azureTelemetryPeriod);

	iothubAuthenticated = true;

	if (IoTHubDeviceClient_LL_SetOption(iothubClientHandle, OPTION_KEEP_ALIVE,
		&keepalivePeriodSeconds) != IOTHUB_CLIENT_OK) {
		Log_Debug("ERROR: failure setting option \"%s\"\n", OPTION_KEEP_ALIVE);
		return;
	}

	//IoTHubDeviceClient_LL_SetDeviceTwinCallback(iothubClientHandle, TwinCallback, NULL);
	IoTHubDeviceClient_LL_SetConnectionStatusCallback(iothubClientHandle,
		HubConnectionStatusCallback, NULL);
}

static const char* GetReasonString(IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason)
{
	static char* reasonString = "unknown reason";
	switch (reason) {
	case IOTHUB_CLIENT_CONNECTION_EXPIRED_SAS_TOKEN:
		reasonString = "IOTHUB_CLIENT_CONNECTION_EXPIRED_SAS_TOKEN";
		break;
	case IOTHUB_CLIENT_CONNECTION_DEVICE_DISABLED:
		reasonString = "IOTHUB_CLIENT_CONNECTION_DEVICE_DISABLED";
		break;
	case IOTHUB_CLIENT_CONNECTION_BAD_CREDENTIAL:
		reasonString = "IOTHUB_CLIENT_CONNECTION_BAD_CREDENTIAL";
		break;
	case IOTHUB_CLIENT_CONNECTION_RETRY_EXPIRED:
		reasonString = "IOTHUB_CLIENT_CONNECTION_RETRY_EXPIRED";
		break;
	case IOTHUB_CLIENT_CONNECTION_NO_NETWORK:
		reasonString = "IOTHUB_CLIENT_CONNECTION_NO_NETWORK";
		break;
	case IOTHUB_CLIENT_CONNECTION_COMMUNICATION_ERROR:
		reasonString = "IOTHUB_CLIENT_CONNECTION_COMMUNICATION_ERROR";
		break;
	case IOTHUB_CLIENT_CONNECTION_OK:
		reasonString = "IOTHUB_CLIENT_CONNECTION_OK";
		break;
	}
	return reasonString;
}

static const char* getAzureSphereProvisioningResultString(
	AZURE_SPHERE_PROV_RETURN_VALUE provisioningResult)
{
	switch (provisioningResult.result) {
	case AZURE_SPHERE_PROV_RESULT_OK:
		return "AZURE_SPHERE_PROV_RESULT_OK";
	case AZURE_SPHERE_PROV_RESULT_INVALID_PARAM:
		return "AZURE_SPHERE_PROV_RESULT_INVALID_PARAM";
	case AZURE_SPHERE_PROV_RESULT_NETWORK_NOT_READY:
		return "AZURE_SPHERE_PROV_RESULT_NETWORK_NOT_READY";
	case AZURE_SPHERE_PROV_RESULT_DEVICEAUTH_NOT_READY:
		return "AZURE_SPHERE_PROV_RESULT_DEVICEAUTH_NOT_READY";
	case AZURE_SPHERE_PROV_RESULT_PROV_DEVICE_ERROR:
		return "AZURE_SPHERE_PROV_RESULT_PROV_DEVICE_ERROR";
	case AZURE_SPHERE_PROV_RESULT_GENERIC_ERROR:
		return "AZURE_SPHERE_PROV_RESULT_GENERIC_ERROR";
	default:
		return "UNKNOWN_RETURN_VALUE";
	}
}

static void SendTelemetry(const unsigned char* key, const unsigned char* key1, const unsigned char* value1,
	const unsigned char* key2, const unsigned char* value2, 
	const unsigned char* key3, const unsigned char* value3,
	const unsigned char* key4, const unsigned char* value4,
	const unsigned char* key5, const unsigned char* value5)
{
	static char eventBuffer[300] = { 0 };
	static const char* EventMsgTemplate = "{ \"%s\": { \
		\"%s\" : \"%s\", \
		\"%s\" : \"%s\", \
		\"%s\" : \"%s\", \
		\"%s\" : \"%s\", \
		\"%s\" : \"%s\"}}";
	int len = snprintf(eventBuffer, sizeof(eventBuffer), EventMsgTemplate, key, 
		key1, value1, key2, value2, key3, value3, key4, value4, key5, value5);
	if (len < 0)
		return;

	Log_Debug("Sending IoT Hub Message: %s\n", eventBuffer);

	IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromString(eventBuffer);

	if (messageHandle == 0) {
		Log_Debug("WARNING: unable to create a new IoTHubMessage\n");
		return;
	}

	if (IoTHubDeviceClient_LL_SendEventAsync(iothubClientHandle, messageHandle, SendMessageCallback,
		/*&callback_param*/ 0) != IOTHUB_CLIENT_OK) {
		Log_Debug("WARNING: failed to hand over the message to IoTHubClient\n");
	}
	else {
		Log_Debug("INFO: IoTHubClient accepted the message for delivery\n");
	}

	IoTHubMessage_Destroy(messageHandle);
}

static void SendMessageCallback(IOTHUB_CLIENT_CONFIRMATION_RESULT result, void* context)
{
	Log_Debug("INFO: Message received by IoT Hub. Result is: %d\n", result);
}

void SendData(void)
{
	double temperature, humidity, pressure, gas_res;

	temperature = get_temperature();
	humidity = get_humidity();
	pressure = get_pressure();
	gas_res = get_gas();

	char tempBuffer[20];
	int len = snprintf(tempBuffer, 20, "%3.2f", temperature);
	char humBuffer[20];
	len = snprintf(humBuffer, 20, "%3.1f", humidity);
	char pressBuffer[20];
	len = snprintf(pressBuffer, 20, "%6.1f", pressure);
	char gasBuffer[20];
	len = snprintf(gasBuffer, 20, "%3.2f", gas_res);

	bool water_present = false;

	if (waterDetectState == GPIO_Value_High) water_present = true;

	char waterPresentBuffer[20];
	len = snprintf(waterPresentBuffer, 20, "%s", water_present ? "true" : "false");

	if (len > 0)
		SendTelemetry("Env_data", "temperature", tempBuffer, "humidity", humBuffer, "pressure",
			pressBuffer, "gas", gasBuffer, "water_present", waterPresentBuffer);

	I2CMaster_Write(i2cFd, bme680_addr, reset_data, sizeof(reset_data));
	init_device();
}

static double get_gas(void)
{
	static const const_array1[] = {1, 1, 1, 1, 1, 0.99, 1, 0.992, 1, 1, 0.998, 0.995, 1, 0.99, 1, 1};
	static const const_array2[] = { 8000000, 4000000, 2000000, 1000000, 499500.4995, 248262.1648,
	125000, 63004.03226, 31281.28128, 15625, 7812.5, 3906.25, 1953.125, 976.5625, 488.28125, 244.140625};

	uint8_t gas_adc_lsb, gas_adc_msb, gas_range, range_switching_error;
	uint16_t raw_gas_adc;
	double gas_res;
	uint8_t current_reg = 0x2B;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &gas_adc_lsb, 1);
	current_reg = 0x2A;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &gas_adc_msb, 1);
	current_reg = 0x2B;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &gas_range, 1);
	current_reg = 0x04;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &range_switching_error, 1);

	raw_gas_adc = (gas_adc_msb << 2) + (gas_adc_lsb >> 6);
	gas_range = gas_range & 0b1111;

	double var1 = (1340.0 + 5.0 * range_switching_error) * const_array1[gas_range];
	gas_res = var1 * const_array2[gas_range] / (raw_gas_adc - 512.0 + var1);
	return gas_res;

}

static double get_pressure(void)
{
	uint32_t raw_press_adc;
	uint8_t par_p1_lsb, par_p1_msb, par_p2_lsb, par_p2_msb, par_p3, par_p4_lsb, par_p4_msb,
		par_p5_lsb, par_p5_msb, par_p6, par_p7, par_p8_lsb, par_p8_msb, par_p9_lsb, par_p9_msb,
		par_p10, press_adc_xlsb, press_adc_lsb, press_adc_msb;
	uint16_t par_p1, par_p2, par_p4, par_p5, par_p8, par_p9;
	uint32_t press_comp;
	uint8_t current_reg = 0x8E;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p1_lsb, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p1_msb, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p2_lsb, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p2_msb, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p3, 1);
	current_reg = 0x94;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p4_lsb, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p4_msb, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p5_lsb, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p5_msb, 1);
	current_reg = 0x99;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p6, 1);
	current_reg--;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p7, 1);
	current_reg = 0x9C;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p8_lsb, 1);
	current_reg = 0x9D;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p8_msb, 1);
	current_reg = 0x9E;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p9_lsb, 1);
	current_reg = 0x9F;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p9_msb, 1);
	current_reg = 0xA0;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_p10, 1);
	current_reg = 0x21;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &press_adc_xlsb, 1);
	current_reg--;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &press_adc_lsb, 1);
	current_reg--;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &press_adc_msb, 1);
	par_p1 = (par_p1_msb << 8) + par_p1_lsb;
	par_p2 = (par_p2_msb << 8) + par_p2_lsb;
	par_p4 = (par_p4_msb << 8) + par_p4_lsb;
	par_p5 = (par_p5_msb << 8) + par_p5_lsb;
	par_p8 = (par_p8_msb << 8) + par_p8_lsb;
	par_p9 = (par_p9_msb << 8) + par_p9_lsb;
	raw_press_adc = (press_adc_msb << 12) + (press_adc_lsb << 4) + (press_adc_xlsb >> 4);

	double t_fine = get_temperature() * 5120.0;

	int32_t var1 = ((int32_t)t_fine >> 1) - 64000;
	int32_t var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * (int32_t)par_p6) >> 2;
	var2 = var2 + ((var1 * (int32_t)par_p5) << 1);
	var2 = (var2 >> 2) + ((int32_t)par_p4 << 16);
	var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) * ((int32_t)par_p3 << 5)) >> 3) +
		(((int32_t)par_p2 * var1) >> 1);
	var1 = var1 >> 18;
	var1 = ((32768 + var1) * (int32_t)par_p1) >> 15;
	press_comp = 1048576 - raw_press_adc;
	press_comp = (uint32_t)((press_comp - (var2 >> 12)) * ((uint32_t)3125));
	if (press_comp >= (1 << 30)) press_comp = ((press_comp / (uint32_t)var1) << 1);
	else press_comp = ((press_comp << 1) / (uint32_t)var1);
	var1 = ((int32_t)par_p9 * (int32_t)(((press_comp >> 3) *
		(press_comp >> 3)) >> 13)) >> 12;
	var2 = ((int32_t)(press_comp >> 2) * (int32_t)par_p8) >> 13;
	int32_t var3 = ((int32_t)(press_comp >> 8) * (int32_t)(press_comp >> 8) *
		(int32_t)(press_comp >> 8) * (int32_t)par_p10) >> 17;
	press_comp = (int32_t)(press_comp)+((var1 + var2 + var3 + ((int32_t)par_p7 << 7)) >> 4);
	Log_Debug("Pressure integer val is %i\n", press_comp);
	return (double)press_comp;


}

static double get_humidity(void)
{
	uint32_t raw_hum_adc;
	uint8_t par_h1_lsb, par_h1_msb, par_h2_lsb, par_h2_msb, par_h3, par_h4, par_h5, par_h6, par_h7,
		hum_adc_lsb, hum_adc_msb;
	uint16_t par_h1, par_h2;
	const double temp_comp = get_temperature();
	uint8_t current_reg = 0xE2;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h1_lsb, 1);
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h2_lsb, 1);
	current_reg = 0xE3;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h1_msb, 1);
	current_reg = 0xE1;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h2_msb, 1);
	current_reg = 0xE4;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h3, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h4, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h5, 1);
	current_reg++;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h6, 1);
	current_reg++; //0xE8
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_h7, 1);
	current_reg = 0x26;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &hum_adc_lsb, 1);
	current_reg = 0x25;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &hum_adc_msb, 1);
	raw_hum_adc = (hum_adc_msb << 8) + hum_adc_lsb;
	par_h1 = (par_h1_msb << 4) + (par_h1_lsb >> 4);
	par_h2 = (par_h2_msb << 4) + (par_h2_lsb >> 4);

	double var1 = raw_hum_adc - (((double)par_h1 * 16.0) + (((double)par_h3 / 2.0) * temp_comp));
	double var2 = var1 * (((double)par_h2 / 262144.0) * (1.0 + (((double)par_h4 / 16384.0) *
		temp_comp) + (((double)par_h5 / 1048576.0) * temp_comp * temp_comp)));
	double var3 = (double)par_h6 / 16384.0;
	double var4 = (double)par_h7 / 2097152.0;

	return var2 + ((var3 + (var4 * temp_comp)) * var2 * var2);

}

static double get_temperature(void)
{
	uint32_t raw_temp_adc;
	uint8_t par_t1_lsb, par_t1_msb, par_t2_lsb, par_t2_msb, par_t3, temp_adc_xlsb,
		temp_adc_lsb, temp_adc_msb;
	uint16_t par_t1, par_t2;
	uint8_t current_reg = 0xE9;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_t1_lsb, 1);
	current_reg = 0xEA;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_t1_msb, 1);
	current_reg = 0x8A;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_t2_lsb, 1);
	current_reg = 0x8B;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_t2_msb, 1);
	current_reg = 0x8C;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &par_t3, 1);
	current_reg = 0x24;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &temp_adc_xlsb, 1);
	current_reg = 0x23;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &temp_adc_lsb, 1);
	current_reg = 0x22;
	I2CMaster_WriteThenRead(i2cFd, bme680_addr, &current_reg, 1, &temp_adc_msb, 1);

	temp_adc_xlsb >>= 4;
	raw_temp_adc = (temp_adc_msb << 12) + (temp_adc_lsb << 4) + temp_adc_xlsb;

	par_t1 = (par_t1_msb << 8) + par_t1_lsb;
	par_t2 = (par_t2_msb << 8) + par_t2_lsb;

	double var1 = (((double)raw_temp_adc / 16384.0) - ((double)par_t1 / 1024.0)) * (double)par_t2;
	double var2 = ((((double)raw_temp_adc / 131072.0) - ((double)par_t1 / 8192.0)) *
		(((double)raw_temp_adc / 131072.0) - ((double)par_t1 / 8192.0))) *
		((double)par_t3 * 16.0);
	double t_fine = var1 + var2;
	double temp_comp = t_fine / 5120.0;
	return temp_comp;
}

#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/timerfd.h>
#include <applibs/log.h>
#include "epoll_timerfd_utilities.h"

int CreateEpollFd(void)
{
	int epollFd = -1;

	epollFd = epoll_create1(0);
	if (epollFd == -1) {
		Log_Debug("ERROR: Could not create epoll instance: %s (%d).\n", strerror(errno), errno);
		return -1;
	}

	return epollFd;
}

int RegisterEventHandlerToEpoll(int epollFd, int eventFd, EventData* persistentEventData,
	const uint32_t epollEventMask)
{
	persistentEventData->fd = eventFd;
	struct epoll_event eventToAddOrModify = { .data.ptr = persistentEventData,
											 .events = epollEventMask };

	// Register the eventFd on the epoll instance referred by epollFd
	// and register the eventHandler handler for events in epollEventMask.
	if (epoll_ctl(epollFd, EPOLL_CTL_ADD, eventFd, &eventToAddOrModify) == -1) {
		// If the Add fails, retry with the Modify as the file descriptor has already been
		// added to the epoll set after it was removed by the kernel upon its closure.
		if (epoll_ctl(epollFd, EPOLL_CTL_MOD, eventFd, &eventToAddOrModify) == -1) {
			Log_Debug("ERROR: Could not register event to epoll instance: %s (%d).\n",
				strerror(errno), errno);
			return -1;
		}
	}

	return 0;
}

int UnregisterEventHandlerFromEpoll(int epollFd, int eventFd)
{
	int res = 0;
	// Unregister the eventFd on the epoll instance referred by epollFd.
	if ((res = epoll_ctl(epollFd, EPOLL_CTL_DEL, eventFd, NULL)) == -1) {
		if (res == -1 && errno != EBADF) { // Ignore EBADF errors
			Log_Debug("ERROR: Could not remove event from epoll instance: %s (%d).\n",
				strerror(errno), errno);
			return -1;
		}
	}

	return 0;
}

int SetTimerFdToPeriod(int timerFd, const struct timespec* period)
{
	struct itimerspec newValue = { .it_value = *period,.it_interval = *period };

	if (timerfd_settime(timerFd, 0, &newValue, NULL) < 0) {
		Log_Debug("ERROR: Could not set timerfd period: %s (%d).\n", strerror(errno), errno);
		return -1;
	}

	return 0;
}

int SetTimerFdToSingleExpiry(int timerFd, const struct timespec* expiry)
{
	struct itimerspec newValue = { .it_value = *expiry,.it_interval = {} };

	if (timerfd_settime(timerFd, 0, &newValue, NULL) < 0) {
		Log_Debug("ERROR: Could not set timerfd interval: %s (%d).\n", strerror(errno), errno);
		return -1;
	}

	return 0;
}

int ConsumeTimerFdEvent(int timerFd)
{
	uint64_t timerData = 0;

	if (read(timerFd, &timerData, sizeof(timerData)) == -1) {
		Log_Debug("ERROR: Could not read timerfd %s (%d).\n", strerror(errno), errno);
		return -1;
	}

	return 0;
}

int CreateTimerFdAndAddToEpoll(int epollFd, const struct timespec* period,
	EventData* persistentEventData, const uint32_t epollEventMask)
{
	// Create the timerfd and arm it by setting the interval to period
	int timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
	if (timerFd < 0) {
		Log_Debug("ERROR: Could not create timerfd: %s (%d).\n", strerror(errno), errno);
		return -1;
	}
	if (SetTimerFdToPeriod(timerFd, period) != 0) {
		int result = close(timerFd);
		if (result != 0) {
			Log_Debug("ERROR: Could not close timerfd: %s (%d).\n", strerror(errno), errno);
		}
		return -1;
	}

	persistentEventData->fd = timerFd;
	if (RegisterEventHandlerToEpoll(epollFd, timerFd, persistentEventData, epollEventMask) != 0) {
		return -1;
	}

	return timerFd;
}

int WaitForEventAndCallHandler(int epollFd)
{
	struct epoll_event event;
	int numEventsOccurred = epoll_wait(epollFd, &event, 1, -1);

	if (numEventsOccurred == -1) {
		if (errno == EINTR) {
			// interrupted by signal, e.g. due to breakpoint being set; ignore
			return 0;
		}
		Log_Debug("ERROR: Failed waiting on events: %s (%d).\n", strerror(errno), errno);
		return -1;
	}

	if (numEventsOccurred == 1 && event.data.ptr != NULL) {
		EventData* eventData = event.data.ptr;
		eventData->eventHandler(eventData);
	}

	return 0;
}

void CloseFdAndPrintError(int fd, const char* fdName)
{
	if (fd >= 0) {
		int result = close(fd);
		if (result != 0) {
			Log_Debug("ERROR: Could not close fd %s: %s (%d).\n", fdName, strerror(errno), errno);
		}
	}
}

#pragma once
#include <time.h>
#include <sys/epoll.h>
#include <unistd.h>

/// Forward declaration of the data type passed to the handlers.
struct EventData;

/// <summary>
///     Function signature for event handlers.
/// </summary>
/// <param name="eventData">The provided event data</param>
typedef void (*EventHandler)(struct EventData* eventData);

/// <summary>
/// <para>Contains context data for epoll events.</para>
/// <para>When an event is registered with RegisterEventHandlerToEpoll, supply
/// a pointer to an instance of this struct.  The pointer must remain valid
/// for as long as the event is active.</para>
/// </summary>
/// <seealso cref="RegisterEventHandlerToEpoll" />
typedef struct EventData {
	/// <summary>
	/// Function which is called when the event occurs.
	/// </summary>
	EventHandler eventHandler;
	/// <summary>
	/// The file descriptor that generated the event.
	/// </summary>
	int fd;
} EventData;

/// <summary>
///    Creates an epoll instance.
/// </summary>
/// <returns>A valid epoll file descriptor on success, or -1 on failure</returns>
int CreateEpollFd(void);

/// <summary>
///     Registers an event with the epoll instance. If the event was previously added, that
///     registration will be modified to match the new mask.
/// </summary>
/// <param name="epollFd">Epoll file descriptor</param>
/// <param name="eventFd">File descriptor generating events for the epoll</param>
/// <param name="persistentEventData">Persistent event data structure. This must stay in memory
/// until the handler is removed from the epoll.</param>
/// <param name="epollEventMask">Bit mask for the epoll event type</param>
/// <returns>0 on success, or -1 on failure</returns>
int RegisterEventHandlerToEpoll(int epollFd, int eventFd, EventData* persistentEventData,
	const uint32_t epollEventMask);

/// <summary>
///     Unregisters an event with the epoll instance.
/// </summary>
/// <param name="epollFd">Epoll file descriptor</param>
/// <param name="eventFd">File descriptor generating events for the epoll</param>
/// <returns>0 on success, or -1 on failure</returns>
int UnregisterEventHandlerFromEpoll(int epollFd, int eventFd);

/// <summary>
///     Sets the period of a timer.
/// </summary>
/// <param name="timerFd">Timer file descriptor</param>
/// <param name="period">The new period</param>
/// <returns>0 on success, or -1 on failure</returns>
int SetTimerFdToPeriod(int timerFd, const struct timespec* period);

/// <summary>
///     Sets a timer to fire once only, after a duration specified in milliseconds.
/// </summary>
/// <param name="timerFd">Timer file descriptor</param>
/// <param name="expiry">The time elapsed before it expires once</param>
/// <returns>0 on success, or -1 on failure</returns>
int SetTimerFdToSingleExpiry(int timerFd, const struct timespec* expiry);

/// <summary>
///     Consumes an event by reading from the timer file descriptor.
///     If the event is not consumed, then it will immediately recur.
/// </summary>
/// <param name="timerFd">Timer file descriptor</param>
/// <returns>0 on success, or -1 on failure</returns>
int ConsumeTimerFdEvent(int timerFd);

/// <summary>
///     Creates a timerfd and adds it to an epoll instance.
/// </summary>
/// <param name="epollFd">Epoll file descriptor</param>
/// <param name="period">The timer period</param>
/// <param name="persistentEventData">Persistent event data structure. This must stay in memory
/// until the handler is removed from the epoll.</param>
/// <param name="epollEventMask">Bit mask for the epoll event type</param>
/// <returns>A valid timerfd file descriptor on success, or -1 on failure</returns>
int CreateTimerFdAndAddToEpoll(int epollFd, const struct timespec* period,
	EventData* persistentEventData, const uint32_t epollEventMask);

/// <summary>
///     Waits for an event on an epoll instance and triggers the handler.
/// </summary>
/// <param name="epollFd">
///     Epoll file descriptor which was created with <see cref="CreateEpollFd" />.
/// </param>
/// <returns>0 on success, or -1 on failure</returns>
int WaitForEventAndCallHandler(int epollFd);

/// <summary>
///     Closes a file descriptor and prints an error on failure.
/// </summary>
/// <param name="fd">File descriptor to close</param>
/// <param name="name">File descriptor name to use in error message</param>
void CloseFdAndPrintError(int fd, const char* name);

#pragma once
#define Ctrl_meas 0x74
#define Ctrl_hum 0x72
#define Ctrl_gas_1 0x71
#define Ctrl_gas_0 0x70
#define Config 0x75
#define Gas_wait_(x) (0x64 + x)
#define Idac_heat_(x) (0x50 + x)
#define Res_heat_(x) (0x5A + x)

#define Gas_r_lsb 0x2B
#define Gas_r_msb 0x2A

#define Hum_lsb 0x26
#define Hum_msb 0x25

#define Temp_xlsb 0x24
#define Temp_lsb 0x23
#define Temp_msb 0x22

#define Press_xlsb 0x21
#define Press_lsb 0x20
#define Press_msb 0x1F

#define BME680_ID 0x61
#define Id 0xD0
#define Reset 0xE0

#define BME680_ADDR 0x77

const uint8_t ctrl_hum_data[] = { Ctrl_hum, 0x01 };
const uint8_t ctrl_meas_data[] = { Ctrl_meas, 0b01010101 };
const uint8_t ctrl_gas_1_data[] = { Ctrl_gas_1, 0b0001000 };
const uint8_t gas_wait_0_data[] = { Gas_wait_(0), 0x59 };
uint8_t res_heat_0_data[] = { Res_heat_(0), 0x00 };
const uint8_t config_data[] = { Config, 0b00001000 };
const uint8_t reset_data[] = { Reset, 0xB6 };