Introduction
Project Overview
Setting up Microsoft Azure IoT Central
Programming the Azure Sphere and Code Modifications
Building the Circuit and Assembly
The Waiting Period

Published October 24, 2019 © LGPL

Growing Crops Indoors with Azure IoT Central

Want a way to control a light and water for your indoor crops using IoT? This project might interest you.

IntermediateFull instructions provided6 hours1,885

Growing Crops Indoors with Azure IoT Central

Things used in this project

Hardware components

Avnet Azure Sphere MT3620 Starter Kit

MIKROE-3357

Container (wood box)

power supply cord

wires (18 AWG)

About a foot is needed.

Grow Light

I got this from an ex-coworker. You can get this from Amazon

screws (#4 x 1/2 In)

Used because my container is a wooden box.

Digilent 5V 2.5A Switching Power Supply

Not exactly what I used, but close enough

Adafruit Peristaltic Liquid Pump with Silicone Tubing

Butt Splices

Used to splice the power supply cord with the 18 AWG wire without soldering. Alternatively, use wire caps

Male-Header 36 Position 1 Row- Long (0.1")

Wires (misc)

misc wires to power the 5V supply to the dev board and the pump.

DC Barrel Jack

Use for the 5V supply

Software apps and online services

Microsoft Azure IoT Central

Microsoft Visual Studio 2019

Hand tools and fabrication machines

Soldering iron (generic)

Rotary Tool

Only needed due to my wooden box. If you're using cardboard or are 3D printing, then this isn't needed.

Story

Introduction

As winter approaches and the harvest season comes to a close. Most hobbyist gardeners usually call it quits for the season.

For me, I wanted to make use of that period from late autumn to late winter/early spring to grow something I can eat, or even experiment with something I've never grown before (like ginseng or indoor potatoes) or even get a head start with growing seeds that I can transplant to my garden next spring (winter melon).

While there are grow lights with timing functions, that is not enough for me.

I want a system that is able to

Turn run a grow light for about ten hours.
The grow light time can be adjusted.
Have the ability to water my plants automatically.
My watering system should NOT water my plants whenever it is dry and should only water it every few days or so.
My watering system should be somewhat adjustable, so instead of every few days, I can adjust it to water once a week if needed.
Analytics is not needed.
Security. I don't want an 'incident' where someone accidentally (or maliciously) turn my watering system 24/7 and flood my garage, kill my plants and waste my power bill or be part of a botnet. Not likely to happen, but you never know.
Scale. In case I want to grow multiple crops indoors that require different light exposure, water level, etc. in the future, I want to manage it all on one system.

Project Overview

For this project, I will be using the Azure Sphere dev board along with Microsoft's Azure IoT Central to create my watering system. However, because this will be using IoT Central, there will be a subscription cost to it.

The Azure Sphere dev board will be attached to a Mikroe 3 click relay module. This relay module will be responsible for controlling the grow light and the watering pump.

The IoT Central will be the main point of interaction and is where all user settings can be adjusted such as time to turn on/off grow light.

Setting up Microsoft Azure IoT Central

Important. This guide assumes you are somewhat familiar with pairing an Avnet Azure Sphere dev board with IoT Central. If not, please refer to the following guide:

After you have created a template, go to the settings tab and do the following:

1) Create four different Number item.

2) Enter in the display name, field Name, Unit of Measure, etc as shown in the table below

3) Create a Toggle

4) Enter in the display name, field Name, Unit of Measure, etc as shown in the table below

The end result should look similar to the following:

You can now migrate the Azure Sphere dev board to the modified template.

Programming the Azure Sphere and Code Modifications

For this project, the demo code provided by Avnet works great as a start point and so, I checked out the sample code at

https://github.com/bawilless/AzureSphereHacksterTTC

and made my own modifications to the deviceTwin.h, device_twin.c, main.c and the app_manifest.json files. The code I modified is shown in the code section.

In main.c, I added several time structs in order to monitor time and added additional logic behavior based on the time (such as how long the pump should be turned on, should the grow light be active, etc.). I also added an option in case I want to turn the pump on locally.

Main.c Addition

Since the dev board will be talking to IoT Central, I need to set the device twin files (device_twin.c and deviceTwin.h) by adding four twin keys in the twinArray dictionary on like 65 (pumpOnTime, timeToAutoWater, growOntime, growoffTime and clickBoardRelay2) as well as additional functions so main.c can get the status of the twin key variables.

During this process I discovered that if a twin device is set up as a boolean but NOT mapped to a GPIO pin, a segmentation fault will occur as it always try to get the GPIO value associated with the Boolean twin device. Since I'm using a toggle command (which is a boolean twin device) but not mapping it to a GPIO pin, I had to remove 178-185 in the device_twin.c file.

Furthermore, since the main.c class needs to talk with the device_twin.c variables, the header file (devicetwin.h) must also be modded so the functions can be called from main.c

For this project, the click 3 Relay is placed on click slot #1. In order to turn on the relay, GPIO pins 16 and 34 must be enabled in app_manifest.json or else you'll get an access error. Furthermore, because the system is time dependent, System Time is also set to true. Note that somewhat sensitive information is censored out

Building the Circuit and Assembly

Since the Azure Sphere dev board includes an interface with Mikroe click boards, there isn't too much to do than wiring the relays. I decided to use relay #1 to control the grow light and relay #2 to control the pump.

To control the grow light, I have to splice a three prog cable. However, because the grow light needs to be placed higher than the pump, which needs to be closer to the ground near a water source, I have to splice the three prog cable with another foot of wire. I ended up splicing the neutral line of the three prog, attached a butt splice and then attaching the additional foot of 18 AWG wire, which then feeds to relay #1.

I am currently using a 5V power supply to power both the Azure Sphere board and the pump and I decided to use a small protoboard as a 5V junction point in order to have an easier time to wire the board to 5V and the pump to the relay.

While optional, I decided to keep everything in a self contained box, but to do so, I'll need to cut several holes in a wooden box using a rotary tool. Afterwards, I screwed the dev Azure Sphere, the pump, and a DC barrel jack using wood screws.

1 / 3

The grow light needs to be somewhat high compared to the pot. I didn't have any fishing wire or a place to mount my grow light and so I ended up using a spare walker lying around.

The Waiting Period

While I'm happy with this project, it is currently the middle of October as of this writing and as a result, I do not have anything growing other than potato sprouts. Unfortunately, at this point, this is playing the waiting game against nature. Once I have something growing, maybe I'll considering scaling the sytem up to grow multiple crops with multiple growlight and have it all be controlled from one IoT Central hub.

#pragma once

#include <applibs/gpio.h>
#include "parson.h"

#define JSON_BUFFER_SIZE 128

typedef enum {
	TYPE_INT = 0,
	TYPE_FLOAT = 1,
	TYPE_BOOL = 2,
	TYPE_STRING = 3
} data_type_t;

typedef struct {
	char* twinKey;
	void* twinVar;
	int* twinFd;
	GPIO_Id twinGPIO;
	data_type_t twinType;
	bool active_high;
} twin_t;

///<summary>
///		Parses received desired property changes.
///</summary>
///<param name="desiredProperties">Address of desired properties JSON_Object</param>
void deviceTwinChangedHandler(JSON_Object* desiredProperties);

void checkAndUpdateDeviceTwin(char*, void*, data_type_t, bool);
int getPumpOnTime();
int getAutoWaterInterval();
int getGrowOnTime();
int getGrowOffTime();
bool isPumpOn();
void shutOffRemotePumpCmd();
int getAutoWaterInterval();

#define NO_GPIO_ASSOCIATED_WITH_TWIN -1

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

// applibs_versions.h defines the API struct versions to use for applibs APIs.
#include "applibs_versions.h"
#include "epoll_timerfd_utilities.h"

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

#include "mt3620_avnet_dev.h"
#include "deviceTwin.h"
#include "azure_iot_utilities.h"
#include "parson.h"
#include "build_options.h"

bool userLedRedIsOn = false;
bool userLedGreenIsOn = false;
bool userLedBlueIsOn = false;
bool wifiLedIsOn = false;
bool clkBoardRelay2IsOn=false;

extern int userLedRedFd;
extern int userLedGreenFd;
extern int userLedBlueFd;

extern int wifiLedFd;
extern int clickSocket1Relay1Fd;
extern int clickSocket1Relay2Fd;
int pumpOnTime=0;
int autoWaterInterval=0;
int growOnTime=6;
int growOffTime=18;

extern volatile sig_atomic_t terminationRequired;

static const char cstrDeviceTwinJsonInteger[] = "{\"%s\": %d}";
static const char cstrDeviceTwinJsonFloat[] = "{\"%s\": %.2f}";
static const char cstrDeviceTwinJsonBool[] = "{\"%s\": %s}";
static const char cstrDeviceTwinJsonString[] = "{\"%s\": \"%s\"}";
#ifdef IOT_CENTRAL_APPLICATION
static const char cstrDeviceTwinJsonFloatIOTC[] = "{\"%s\": {\"value\": %.2f, \"status\" : \"completed\" , \"desiredVersion\" : %d }}";
static const char cstrDeviceTwinJsonBoolIOTC[] = "{\"%s\": {\"value\": %s, \"status\" : \"completed\" , \"desiredVersion\" : %d }}";
static const char cstrDeviceTwinJsonIntegerIOTC[] = "{\"%s\": {\"value\": %d, \"status\" : \"completed\" , \"desiredVersion\" : %d }}";
static const char cstrDeviceTwinJsonStringIOTC[] = "{\"%s\": {\"value\": %s, \"status\" : \"completed\" , \"desiredVersion\" : %d }}";
#endif 

static int desiredVersion = 0;

// Define each device twin key that we plan to catch, process, and send reported property for.
// .twinKey - The JSON Key piece of the key: value pair
// .twinVar - The address of the application variable keep this key: value pair data
// .twinFD - The associated File Descriptor for this item.  This is usually a GPIO FD.  NULL if NA.
// .twinGPIO - The associted GPIO number for this item.  NO_GPIO_ASSOCIATED_WITH_TWIN if NA
// .twinType - The data type for this item, TYPE_BOOL, TYPE_STRING, TYPE_INT, or TYPE_FLOAT
// .active_high - true if GPIO item is active high, false if active low.  This is used to init the GPIO 
twin_t twinArray[] = {
	{.twinKey = "userLedRed",.twinVar = &userLedRedIsOn,.twinFd = &userLedRedFd,.twinGPIO = MT3620_RDB_LED1_RED,.twinType = TYPE_BOOL,.active_high = false},
	{.twinKey = "userLedGreen",.twinVar = &userLedGreenIsOn,.twinFd = &userLedGreenFd,.twinGPIO = MT3620_RDB_LED1_GREEN,.twinType = TYPE_BOOL,.active_high = false},
	{.twinKey = "userLedBlue",.twinVar = &userLedBlueIsOn,.twinFd = &userLedBlueFd,.twinGPIO = MT3620_RDB_LED1_BLUE,.twinType = TYPE_BOOL,.active_high = false},
	{.twinKey = "wifiLed",.twinVar = &wifiLedIsOn,.twinFd = &wifiLedFd,.twinGPIO = AVT_LED_WIFI,.twinType = TYPE_BOOL,.active_high = false},
	{.twinKey = "pumpOnTime",.twinVar = &pumpOnTime,.twinFd = NULL,.twinGPIO = NO_GPIO_ASSOCIATED_WITH_TWIN,.twinType = TYPE_INT},
	{.twinKey = "timeToAutoWater",.twinVar = &autoWaterInterval,.twinFd = NULL,.twinGPIO = NO_GPIO_ASSOCIATED_WITH_TWIN,.twinType = TYPE_INT},
	{.twinKey = "growOnTime",.twinVar = &growOnTime,.twinFd = NULL,.twinGPIO = NO_GPIO_ASSOCIATED_WITH_TWIN,.twinType = TYPE_INT},
	{.twinKey = "growOffTime",.twinVar = &growOffTime,.twinFd = NULL,.twinGPIO = NO_GPIO_ASSOCIATED_WITH_TWIN,.twinType = TYPE_INT},
	{.twinKey = "clickBoardRelay2",.twinVar = &clkBoardRelay2IsOn,.twinFd = NULL,.twinGPIO = NO_GPIO_ASSOCIATED_WITH_TWIN,.twinType = TYPE_BOOL}
};

// Calculate how many twin_t items are in the array.  We use this to iterate through the structure.
int twinArraySize = sizeof(twinArray) / sizeof(twin_t);

int getPumpOnTime() { return pumpOnTime; }
int getAutoWaterInterval() { return autoWaterInterval; }
int getGrowOnTime() { return growOnTime; }
int getGrowOffTime() { return growOffTime; }

bool isPumpOn() { return clkBoardRelay2IsOn; }
void shutOffRemotePumpCmd() { clkBoardRelay2IsOn=false; }

///<summary>
///		check to see if any of the device twin properties have been updated.  If so, send up the current data.
///</summary>
void checkAndUpdateDeviceTwin(char* property, void* value, data_type_t type, bool ioTCentralFormat)
{
	int nJsonLength = -1;

	char *pjsonBuffer = (char *)malloc(JSON_BUFFER_SIZE);
	if (pjsonBuffer == NULL) {
		Log_Debug("ERROR: not enough memory to report device twin changes.");
	}

	if (property != NULL) {

		// report current device twin data as reported properties to IoTHub

		switch (type) {
		case TYPE_BOOL:
#ifdef IOT_CENTRAL_APPLICATION
			if (ioTCentralFormat) {
				nJsonLength = snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrDeviceTwinJsonBoolIOTC, property, *(bool*)value ? "true" : "false", desiredVersion);
			}
			else
#endif 
				nJsonLength = snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrDeviceTwinJsonBool, property, *(bool*)value ? "true" : "false", desiredVersion);

			break;
		case TYPE_FLOAT:
#ifdef IOT_CENTRAL_APPLICATION			
			if (ioTCentralFormat) {
				nJsonLength = snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrDeviceTwinJsonFloatIOTC, property, *(float*)value, desiredVersion);
			}
			else
#endif 
				nJsonLength = snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrDeviceTwinJsonFloat, property, *(float*)value, desiredVersion);
			break;
		case TYPE_INT:
#ifdef IOT_CENTRAL_APPLICATION		
			if (ioTCentralFormat) {
				nJsonLength = snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrDeviceTwinJsonIntegerIOTC, property, *(int*)value, desiredVersion);
			}
			else
#endif
				nJsonLength = snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrDeviceTwinJsonInteger, property, *(int*)value, desiredVersion);
			break;
		case TYPE_STRING:
#ifdef IOT_CENTRAL_APPLICATION			
			if (ioTCentralFormat) {
				nJsonLength = snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrDeviceTwinJsonStringIOTC, property, (char*)value, desiredVersion);
			}
			else
#endif 
				nJsonLength = snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrDeviceTwinJsonString, property, (char*)value, desiredVersion);
			break;
		}

		if (nJsonLength > 0) {
			Log_Debug("[MCU] Updating device twin: %s\n", pjsonBuffer);
			AzureIoT_TwinReportStateJson(pjsonBuffer, (size_t)nJsonLength);
		}
		free(pjsonBuffer);
	}
}

///<summary>
///		Parses received desired property changes.
///</summary>
///<param name="desiredProperties">Address of desired properties JSON_Object</param>
void deviceTwinChangedHandler(JSON_Object * desiredProperties)
{
	int result = 0;

	// Pull the twin version out of the message.  We use this value when we echo the new setting back to IoT Connect.
	if (json_object_has_value(desiredProperties, "$version") != 0)
	{
		desiredVersion = (int)json_object_get_number(desiredProperties, "$version");
	}

#ifdef IOT_CENTRAL_APPLICATION		

	for (int i = 0; i < (sizeof(twinArray) / sizeof(twin_t)); i++) {

		if (json_object_has_value(desiredProperties, twinArray[i].twinKey) != 0)
		{

			JSON_Object *currentJSONProperties = json_object_dotget_object(desiredProperties, twinArray[i].twinKey);

			switch (twinArray[i].twinType) {
			case TYPE_BOOL:
				*(bool*)twinArray[i].twinVar = (bool)json_object_get_boolean(currentJSONProperties, "value");
				Log_Debug("Received device update. New %s is %s\n", twinArray[i].twinKey, *(bool*)twinArray[i].twinVar ? "true" : "false");
				checkAndUpdateDeviceTwin(twinArray[i].twinKey, twinArray[i].twinVar, TYPE_BOOL, true);
				break;
			case TYPE_FLOAT:
				*(float*)twinArray[i].twinVar = (float)json_object_get_number(currentJSONProperties, "value");
				Log_Debug("Received device update. New %s is %0.2f\n", twinArray[i].twinKey, *(float*)twinArray[i].twinVar);
				checkAndUpdateDeviceTwin(twinArray[i].twinKey, twinArray[i].twinVar, TYPE_FLOAT, true);
				break;
			case TYPE_INT:
				*(int*)twinArray[i].twinVar = (int)json_object_get_number(currentJSONProperties, "value");
				Log_Debug("Received device update. New %s is %d\n", twinArray[i].twinKey, *(int*)twinArray[i].twinVar);
				checkAndUpdateDeviceTwin(twinArray[i].twinKey, twinArray[i].twinVar, TYPE_INT, true);
				break;
			case TYPE_STRING:
				Log_Debug("ERROR: TYPE_STRING case not implemented!");
				break;
			}
		}
	}
#else // !IOT_CENTRAL_APPLICATION		
	
	for (int i = 0; i < (sizeof(twinArray) / sizeof(twin_t)); i++) {

		if (json_object_has_value(desiredProperties, twinArray[i].twinKey) != 0)
		{

			switch (twinArray[i].twinType) {
			case TYPE_BOOL:
				*(bool*)twinArray[i].twinVar = (bool)json_object_get_boolean(desiredProperties, twinArray[i].twinKey);
				result = GPIO_SetValue(*twinArray[i].twinFd, twinArray[i].active_high ? (GPIO_Value)*(bool*)twinArray[i].twinVar : !(GPIO_Value)*(bool*)twinArray[i].twinVar);

				if (result != 0) {
					Log_Debug("Fd: %d\n", twinArray[i].twinFd);
					Log_Debug("FAILURE: Could not set GPIO_%d, %d output value %d: %s (%d).\n", twinArray[i].twinGPIO, twinArray[i].twinFd, (GPIO_Value)*(bool*)twinArray[i].twinVar, strerror(errno), errno);
					terminationRequired = true;
				}
				Log_Debug("Received device update. New %s is %s\n", twinArray[i].twinKey, *(bool*)twinArray[i].twinVar ? "true" : "false");
				checkAndUpdateDeviceTwin(twinArray[i].twinKey, twinArray[i].twinVar, TYPE_BOOL, true);
				break;
			case TYPE_FLOAT:
				*(float*)twinArray[i].twinVar = (float)json_object_get_number(desiredProperties, twinArray[i].twinKey);
				Log_Debug("Received device update. New %s is %0.2f\n", twinArray[i].twinKey, *(float*)twinArray[i].twinVar);
				checkAndUpdateDeviceTwin(twinArray[i].twinKey, twinArray[i].twinVar, TYPE_FLOAT, true);
				break;
			case TYPE_INT:
				*(int*)twinArray[i].twinVar = (int)json_object_get_number(desiredProperties, twinArray[i].twinKey);
				Log_Debug("Received device update. New %s is %d\n", twinArray[i].twinKey, *(int*)twinArray[i].twinVar);
				checkAndUpdateDeviceTwin(twinArray[i].twinKey, twinArray[i].twinVar, TYPE_INT, true);
				break;
			case TYPE_STRING:
				Log_Debug("ERROR: TYPE_STRING case not implemented!");
				break;
			}
		}
	}
#endif 

}

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

   // applibs_versions.h defines the API struct versions to use for applibs APIs.
#include "applibs_versions.h"
#include "epoll_timerfd_utilities.h"
#include "i2c.h"
#include "mt3620_avnet_dev.h"
#include "deviceTwin.h"
#include "azure_iot_utilities.h"
#include "connection_strings.h"
#include "build_options.h"

#include <applibs/log.h>
#include <applibs/i2c.h>
#include <applibs/gpio.h>
#include <applibs/wificonfig.h>
#include <azureiot/iothub_device_client_ll.h>

// Provide local access to variables in other files
extern twin_t twinArray[];
extern int twinArraySize;
extern IOTHUB_DEVICE_CLIENT_LL_HANDLE iothubClientHandle;

// Support functions.
static void TerminationHandler(int signalNumber);
static int InitPeripheralsAndHandlers(void);
static void ClosePeripheralsAndHandlers(void);

// File descriptors - initialized to invalid value
int epollFd = -1;
static int buttonPollTimerFd = -1;
static int buttonAGpioFd = -1;
static int buttonBGpioFd = -1;

int userLedRedFd = -1;
int userLedGreenFd = -1;
int userLedBlueFd = -1;
int wifiLedFd = -1;
int clickSocket1Relay1Fd = -1;
int clickSocket1Relay2Fd = -1;

//Member variables for this project
struct timespec pumpStartTime, pumpEndTime, growLightStartTime, growLightEndTime, lastKnownWateredTime, currentTime;
bool pumpActive = false;
static int pumpFd = -1;
static int growFd = -1;

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


// Button state variables, initilize them to button not-pressed (High)
static GPIO_Value_Type buttonAState = GPIO_Value_High;
static GPIO_Value_Type buttonBState = GPIO_Value_High;

#if (defined(IOT_CENTRAL_APPLICATION) || defined(IOT_HUB_APPLICATION))
bool versionStringSent = false;
#endif

// Define the Json string format for the accelerator button press data
static const char cstrButtonTelemetryJson[] = "{\"%s\":\"%d\"}";

// Termination state
volatile sig_atomic_t terminationRequired = false;

/// <summary>
///     Signal handler for termination requests. This handler must be async-signal-safe.
/// </summary>
static void TerminationHandler(int signalNumber)
{
	// Don't use Log_Debug here, as it is not guaranteed to be async-signal-safe.
	terminationRequired = true;
}

/// <summary>
///     Handle button timer event: if the button is pressed, report the event to the IoT Hub.
/// </summary>
static void ButtonTimerEventHandler(EventData* eventData)
{

	bool sendTelemetryButtonA = false;
	bool sendTelemetryButtonB = false;

	if (ConsumeTimerFdEvent(buttonPollTimerFd) != 0) {
		terminationRequired = true;
		return;
	}

	// Check for button A press
	GPIO_Value_Type newButtonAState;
	int result = GPIO_GetValue(buttonAGpioFd, &newButtonAState);
	if (result != 0) {
		Log_Debug("ERROR: Could not read button GPIO: %s (%d).\n", strerror(errno), errno);
		terminationRequired = true;
		return;
	}

	// If the A button has just been pressed, send a telemetry message
	// The button has GPIO_Value_Low when pressed and GPIO_Value_High when released
	if (newButtonAState != buttonAState) {
		if (newButtonAState == GPIO_Value_Low) {
			Log_Debug("Button A pressed!\n");
			sendTelemetryButtonA = true;
		}
		//Once the A Button is released, then start the pump for three minutes
		else {
			Log_Debug("Button A released!\n");

			//Turn on the pump iff it isn't active
			if (pumpActive == false) {
				//Set pump flag to true
				pumpActive = true;
				//Get the start time
				clock_gettime(CLOCK_MONOTONIC, &pumpStartTime);

			}
		}

		// Update the static variable to use next time we enter this routine
		buttonAState = newButtonAState;
	}

	// Check for button B press
	GPIO_Value_Type newButtonBState;
	result = GPIO_GetValue(buttonBGpioFd, &newButtonBState);
	if (result != 0) {
		Log_Debug("ERROR: Could not read button GPIO: %s (%d).\n", strerror(errno), errno);
		terminationRequired = true;
		return;
	}

	// If the B button has just been pressed/released, send a telemetry message
	// The button has GPIO_Value_Low when pressed and GPIO_Value_High when released
	if (newButtonBState != buttonBState) {
		if (newButtonBState == GPIO_Value_Low) {
			// Send Telemetry here
			Log_Debug("Button B pressed!\n");
			sendTelemetryButtonB = true;
		}
		else {
			Log_Debug("Button B released!\n");

		}

		// Update the static variable to use next time we enter this routine
		buttonBState = newButtonBState;
	}

	// If either button was pressed, then enter the code to send the telemetry message
	if (sendTelemetryButtonA || sendTelemetryButtonB) {

		char* pjsonBuffer = (char*)malloc(JSON_BUFFER_SIZE);
		if (pjsonBuffer == NULL) {
			Log_Debug("ERROR: not enough memory to send telemetry");
		}

		if (sendTelemetryButtonA) {
			// construct the telemetry message  for Button A
			snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrButtonTelemetryJson, "buttonA", newButtonAState);
			Log_Debug("\n[Info] Sending telemetry %s\n", pjsonBuffer);
			AzureIoT_SendMessage(pjsonBuffer);
		}

		if (sendTelemetryButtonB) {
			// construct the telemetry message for Button B
			snprintf(pjsonBuffer, JSON_BUFFER_SIZE, cstrButtonTelemetryJson, "buttonB", newButtonBState);
			Log_Debug("\n[Info] Sending telemetry %s\n", pjsonBuffer);
			AzureIoT_SendMessage(pjsonBuffer);
		}

		free(pjsonBuffer);
	}

}

// event handler data structures. Only the event handler field needs to be populated.
static EventData buttonEventData = { .eventHandler = &ButtonTimerEventHandler };

/// <summary>
///     Set up SIGTERM termination handler, initialize peripherals, and set up event handlers.
/// </summary>
/// <returns>0 on success, or -1 on failure</returns>
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;
	}

	if (initI2c() == -1) {
		return -1;
	}

	// Traverse the twin Array and for each GPIO item in the list open the file descriptor
	for (int i = 0; i < twinArraySize; i++) {

		// Verify that this entry is a GPIO entry
		if (twinArray[i].twinGPIO != NO_GPIO_ASSOCIATED_WITH_TWIN) {

			*twinArray[i].twinFd = -1;

			// For each item in the data structure, initialize the file descriptor and open the GPIO for output.  Initilize each GPIO to its specific inactive state.
			*twinArray[i].twinFd = (int)GPIO_OpenAsOutput(twinArray[i].twinGPIO, GPIO_OutputMode_PushPull, twinArray[i].active_high ? GPIO_Value_Low : GPIO_Value_High);

			if (*twinArray[i].twinFd < 0) {
				Log_Debug("ERROR: Could not open LED %d: %s (%d).\n", twinArray[i].twinGPIO, strerror(errno), errno);
				return -1;
			}
		}
	}

	// Open button A GPIO as input
	Log_Debug("Opening Starter Kit Button A as input.\n");
	buttonAGpioFd = GPIO_OpenAsInput(MT3620_RDB_BUTTON_A);
	if (buttonAGpioFd < 0) {
		Log_Debug("ERROR: Could not open button A GPIO: %s (%d).\n", strerror(errno), errno);
		return -1;
	}
	// Open button B GPIO as input
	Log_Debug("Opening Starter Kit Button B as input.\n");
	buttonBGpioFd = GPIO_OpenAsInput(MT3620_RDB_BUTTON_B);
	if (buttonBGpioFd < 0) {
		Log_Debug("ERROR: Could not open button B GPIO: %s (%d).\n", strerror(errno), errno);
		return -1;
	}
	//These are the file descriptors for the relays
	pumpFd = GPIO_OpenAsOutput(AVT_SK_CM1_CS, GPIO_OutputMode_PushPull, GPIO_Value_Low);
	growFd = GPIO_OpenAsOutput(AVT_SK_CM1_RST, GPIO_OutputMode_PushPull, GPIO_Value_Low);
	if (pumpFd < 0 || growFd < 0) {
		Log_Debug("ERROR: Could not open relay GPIO: %s (%d).\n", strerror(errno), errno);
		return -1;
	}



	// Set up a timer to poll the buttons
	struct timespec buttonPressCheckPeriod = { 0, 1000000 };
	buttonPollTimerFd =
		CreateTimerFdAndAddToEpoll(epollFd, &buttonPressCheckPeriod, &buttonEventData, EPOLLIN);
	if (buttonPollTimerFd < 0) {
		return -1;
	}

	// Tell the system about the callback function that gets called when we receive a device twin update message from Azure
	AzureIoT_SetDeviceTwinUpdateCallback(&deviceTwinChangedHandler);

	return 0;
}

/// <summary>
///     Close peripherals and handlers.
/// </summary>
static void ClosePeripheralsAndHandlers(void)
{
	Log_Debug("Closing file descriptors.\n");

	closeI2c();
	CloseFdAndPrintError(epollFd, "Epoll");
	CloseFdAndPrintError(buttonPollTimerFd, "buttonPoll");
	CloseFdAndPrintError(buttonAGpioFd, "buttonA");
	CloseFdAndPrintError(buttonBGpioFd, "buttonB");

	// Traverse the twin Array and for each GPIO item in the list the close the file descriptor
	for (int i = 0; i < twinArraySize; i++) {

		// Verify that this entry has an open file descriptor
		if (twinArray[i].twinGPIO != NO_GPIO_ASSOCIATED_WITH_TWIN) {

			CloseFdAndPrintError(*twinArray[i].twinFd, twinArray[i].twinKey);
		}
	}
}

/// <summary>
///     Main entry point for this application.
/// </summary>
int main(int argc, char* argv[])
{
	// Variable to help us send the version string up only once
	bool networkConfigSent = false;
	bool growLightOn = false;
	char ssid[128];
	uint32_t frequency;
	char bssid[20];
	uint64_t pumpTime;
	// Initialize the ssid array
	memset(ssid, 0, 128);

	uint64_t lastWateredTime;
	bool isTimeSyncEnabled = false;
	int result = Networking_TimeSync_GetEnabled(&isTimeSyncEnabled);
	setenv("TZ", "PST+8", 1);
	tzset();

#if (defined(IOT_CENTRAL_APPLICATION) || defined(IOT_HUB_APPLICATION))
	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;
	}
#endif 

	Log_Debug("Avnet Starter Kit Simple Reference Application starting.\n");
	if (InitPeripheralsAndHandlers() != 0) {
		terminationRequired = true;
	}

	const struct timespec sleep = { 1,0 };
	// Use epoll to wait for events and trigger handlers, until an error or SIGTERM happens
	while (!terminationRequired) {
		if (WaitForEventAndCallHandler(epollFd) != 0) {
			terminationRequired = true;
		}

#if (defined(IOT_CENTRAL_APPLICATION) || defined(IOT_HUB_APPLICATION))
		// Setup the IoT Hub client.
		// Notes:
		// - it is safe to call this function even if the client has already been set up, as in
		//   this case it would have no effect;
		// - a failure to setup the client is a fatal error.
		if (!AzureIoT_SetupClient()) {
			Log_Debug("ERROR: Failed to set up IoT Hub client\n");
		}
#endif 

		WifiConfig_ConnectedNetwork network;
		int result = WifiConfig_GetCurrentNetwork(&network);
		if (result < 0) {
			// Log_Debug("INFO: Not currently connected to a WiFi network.\n");
		}
		else {

			frequency = network.frequencyMHz;
			snprintf(bssid, JSON_BUFFER_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x",
				network.bssid[0], network.bssid[1], network.bssid[2],
				network.bssid[3], network.bssid[4], network.bssid[5]);

			if ((strncmp(ssid, (char*)& network.ssid, network.ssidLength) != 0) || !networkConfigSent) {

				// Clear the ssid array
				memset(ssid, 0, 128);
				strncpy(ssid, network.ssid, network.ssidLength);
				Log_Debug("SSID: %s\n", ssid);
				Log_Debug("Frequency: %dMHz\n", frequency);
				Log_Debug("bssid: %s\n", bssid);
				networkConfigSent = true;

#if (defined(IOT_CENTRAL_APPLICATION) || defined(IOT_HUB_APPLICATION))
				// Note that we send up this data to Azure if it changes, but the IoT Central Properties elements only 
				// show the data that was currenet when the device first connected to Azure.
				checkAndUpdateDeviceTwin("ssid", &ssid, TYPE_STRING, true);
				checkAndUpdateDeviceTwin("freq", &frequency, TYPE_INT, false);
				checkAndUpdateDeviceTwin("bssid", &bssid, TYPE_STRING, false);
#endif 
			}
		}
#if (defined(IOT_CENTRAL_APPLICATION) || defined(IOT_HUB_APPLICATION))
		if (iothubClientHandle != NULL && !versionStringSent) {

			#warning "If you need to upodate the version string do so in main.c ~line 375!"
				checkAndUpdateDeviceTwin("versionString", "AvnetStarterKit-Hackster.io-V1.0", TYPE_STRING, false);
			versionStringSent = true;
		}


		//Main meat of my code starts here

		//Get the current time. Always important
		clock_gettime(CLOCK_REALTIME, &currentTime);

		//See if the remote command is toggled. If it is, set a start time to the pump
		if (isPumpOn() && pumpActive == false) {
			clock_gettime(CLOCK_MONOTONIC, &pumpStartTime);
			pumpActive = true;
		}
		//Check the pump and see if it is active or not
		if (pumpActive) {
			GPIO_SetValue(pumpFd, GPIO_Value_High);
			clock_gettime(CLOCK_MONOTONIC, &pumpEndTime);
			pumpTime = (pumpEndTime.tv_sec - pumpStartTime.tv_sec);
			if (pumpTime >= getPumpOnTime() * 60) {
				//Close the pump (clickRelay)
				GPIO_SetValue(pumpFd, GPIO_Value_Low);
				//Set the Pump flag to false
				pumpActive = false;

				//Update the twin device associated with the remote pump. 
				shutOffRemotePumpCmd();
				//Get the last known watered time
				clock_gettime(CLOCK_MONOTONIC, &lastKnownWateredTime);
				pumpTime = 0;

			}
		}

		//If it has been more than X days since the last watering...water it
		struct tm* timeNow = localtime(&currentTime.tv_sec);
		//Becasue the watering interval is in days, you have to get the hour difference
		if ((lastKnownWateredTime.tv_sec - currentTime.tv_sec) > (getAutoWaterInterval() * 24 * 60 * 60)) {
			pumpActive = true;
		}

		//Turn grow light on if it is within hours of operation
		if ((timeNow->tm_hour >= getGrowOnTime() && timeNow->tm_hour <= getGrowOffTime()) && !growLightOn) {
			//Turn on the grow light
			GPIO_SetValue(growFd, GPIO_Value_High);
			growLightOn = true;
		}

		//Turn grow light off if it is outside of hours of operation
		if ((timeNow->tm_hour  <getGrowOnTime() || timeNow->tm_hour > getGrowOffTime()) && growLightOn) {
			//Turn on the grow light
			GPIO_SetValue(growFd, GPIO_Value_Low);
			growLightOn = false;
		}

		// AzureIoT_DoPeriodicTasks() needs to be called frequently in order to keep active
		// the flow of data with the Azure IoT Hub
		AzureIoT_DoPeriodicTasks();
#endif
	}

	ClosePeripheralsAndHandlers();
	Log_Debug("Application exiting.\n");
	return 0;
}