shadow_sample for docker pi relay

shadow_sample.c

/*
 * Tencent is pleased to support the open source community by making IoT Hub available.
 * Copyright (C) 2016 THL A29 Limited, a Tencent company. All rights reserved.

 * Licensed under the MIT License (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://opensource.org/licenses/MIT

 * Unless required by applicable law or agreed to in writing, software distributed under the License is
 * distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <signal.h>
#include "qcloud_iot_export.h"

#include <wiringPi.h>
#include <wiringPiI2C.h>

#ifdef AUTH_MODE_CERT
static char sg_cert_file[PATH_MAX + 1]; //客户端证书全路径
static char sg_key_file[PATH_MAX + 1];  //客户端密钥全路径
#endif

static DeviceInfo sg_devInfo;

static char sg_shadow_update_buffer[200];
size_t sg_shadow_update_buffersize = sizeof(sg_shadow_update_buffer) / sizeof(sg_shadow_update_buffer[0]);

static DeviceProperty relay_first_shadow_property;
static bool relay_first_status = false;
static bool relay_first_delta_arrived = false;

static DeviceProperty relay_second_shadow_property;
static bool relay_second_status = false;
static bool relay_second_delta_arrived = false;

static DeviceProperty relay_third_shadow_property;
static bool relay_third_status = false;
static bool relay_third_delta_arrived = false;

static DeviceProperty relay_fourth_shadow_property;
static bool relay_fourth_status = false;
static bool relay_fourth_delta_arrived = false;

static bool update_require = true;

void RelayFirstOnDeltaCallback(void *pClient, const char *pJsonValueBuffer, uint32_t valueLength, DeviceProperty *pProperty)
{
	int rc = IOT_Shadow_JSON_ConstructDesireAllNull(pClient, sg_shadow_update_buffer, sg_shadow_update_buffersize);

	if (rc == QCLOUD_ERR_SUCCESS)
	{
		relay_first_delta_arrived = true;
	}
	else
	{
		Log_e("construct desire failed, err: %d", rc);
	}
}

void RelaySecondOnDeltaCallback(void *pClient, const char *pJsonValueBuffer, uint32_t valueLength, DeviceProperty *pProperty)
{
	int rc = IOT_Shadow_JSON_ConstructDesireAllNull(pClient, sg_shadow_update_buffer, sg_shadow_update_buffersize);

	if (rc == QCLOUD_ERR_SUCCESS)
	{
		relay_second_delta_arrived = true;
	}
	else
	{
		Log_e("construct desire failed, err: %d", rc);
	}
}

void RelayThirdOnDeltaCallback(void *pClient, const char *pJsonValueBuffer, uint32_t valueLength, DeviceProperty *pProperty)
{
	int rc = IOT_Shadow_JSON_ConstructDesireAllNull(pClient, sg_shadow_update_buffer, sg_shadow_update_buffersize);

	if (rc == QCLOUD_ERR_SUCCESS)
	{
		relay_third_delta_arrived = true;
	}
	else
	{
		Log_e("construct desire failed, err: %d", rc);
	}
}

void RelayFourthOnDeltaCallback(void *pClient, const char *pJsonValueBuffer, uint32_t valueLength, DeviceProperty *pProperty)
{
	int rc = IOT_Shadow_JSON_ConstructDesireAllNull(pClient, sg_shadow_update_buffer, sg_shadow_update_buffersize);

	if (rc == QCLOUD_ERR_SUCCESS)
	{
		relay_fourth_delta_arrived = true;
	}
	else
	{
		Log_e("construct desire failed, err: %d", rc);
	}
}

static int _setup_connect_init_params(ShadowInitParams *initParams)
{
	int ret;

	ret = HAL_GetDevInfo((void *)&sg_devInfo);
	if (QCLOUD_ERR_SUCCESS != ret)
	{
		return ret;
	}

	initParams->device_name = sg_devInfo.device_name;
	initParams->product_id = sg_devInfo.product_id;

#ifdef AUTH_MODE_CERT
	/* 使用非对称加密*/
	char certs_dir[PATH_MAX + 1] = "certs";
	char current_path[PATH_MAX + 1];
	char *cwd = getcwd(current_path, sizeof(current_path));
	if (cwd == NULL)
	{
		Log_e("getcwd return NULL");
		return QCLOUD_ERR_FAILURE;
	}
	sprintf(sg_cert_file, "%s/%s/%s", current_path, certs_dir, sg_devInfo.devCertFileName);
	sprintf(sg_key_file, "%s/%s/%s", current_path, certs_dir, sg_devInfo.devPrivateKeyFileName);

	initParams->cert_file = sg_cert_file;
	initParams->key_file = sg_key_file;
#else
	initParams->device_secret = sg_devInfo.devSerc;
#endif

	initParams->command_timeout = QCLOUD_IOT_MQTT_COMMAND_TIMEOUT;
	initParams->keep_alive_interval_ms = QCLOUD_IOT_MQTT_KEEP_ALIVE_INTERNAL;
	initParams->auto_connect_enable = 1;

	return QCLOUD_ERR_SUCCESS;
}

int demo_device_shadow()
{
	int rc = QCLOUD_ERR_FAILURE;
    	int relay_fd;
	void *shadow_client = NULL;

	relay_fd = wiringPiI2CSetup(0x10);

	//init connection
	ShadowInitParams init_params = DEFAULT_SHAWDOW_INIT_PARAMS;
	rc = _setup_connect_init_params(&init_params);
	if (rc != QCLOUD_ERR_SUCCESS)
	{
		Log_e("init params err,rc=%d", rc);
		return rc;
	}

	shadow_client = IOT_Shadow_Construct(&init_params);
	if (shadow_client == NULL)
	{
		Log_e("shadow client constructed failed.");
		return QCLOUD_ERR_FAILURE;
	}

	//注册delta属性
	relay_first_shadow_property.key = "relay_first";
	relay_first_shadow_property.data = &relay_first_status;
	relay_first_shadow_property.type = JBOOL;

	relay_second_shadow_property.key = "relay_second";
	relay_second_shadow_property.data = &relay_second_status;
	relay_second_shadow_property.type = JBOOL;

	relay_third_shadow_property.key = "relay_third";
	relay_third_shadow_property.data = &relay_third_status;
	relay_third_shadow_property.type = JBOOL;

	relay_fourth_shadow_property.key = "relay_fourth";
	relay_fourth_shadow_property.data = &relay_fourth_status;
	relay_fourth_shadow_property.type = JBOOL;

	rc = IOT_Shadow_Register_Property(shadow_client, &relay_first_shadow_property, RelayFirstOnDeltaCallback);
	if (rc != QCLOUD_ERR_SUCCESS)
	{
		rc = IOT_Shadow_Destroy(shadow_client);
		Log_e("register device shadow property failed, err: %d", rc);
		return rc;
	}

	rc = IOT_Shadow_Register_Property(shadow_client, &relay_second_shadow_property, RelaySecondOnDeltaCallback);
	if (rc != QCLOUD_ERR_SUCCESS)
	{
		rc = IOT_Shadow_Destroy(shadow_client);
		Log_e("register device shadow property failed, err: %d", rc);
		return rc;
	}

	rc = IOT_Shadow_Register_Property(shadow_client, &relay_third_shadow_property, RelayThirdOnDeltaCallback);
	if (rc != QCLOUD_ERR_SUCCESS)
	{
		rc = IOT_Shadow_Destroy(shadow_client);
		Log_e("register device shadow property failed, err: %d", rc);
		return rc;
	}

	rc = IOT_Shadow_Register_Property(shadow_client, &relay_fourth_shadow_property, RelayFourthOnDeltaCallback);
	if (rc != QCLOUD_ERR_SUCCESS)
	{
		rc = IOT_Shadow_Destroy(shadow_client);
		Log_e("register device shadow property failed, err: %d", rc);
		return rc;
	}

	//进行Shdaow Update操作的之前，最后进行一次同步操作，否则可能本机上shadow version和云上不一致导致Shadow Update操作失败
	rc = IOT_Shadow_Get_Sync(shadow_client, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);
	if (rc != QCLOUD_ERR_SUCCESS)
	{
		Log_e("get device shadow failed, err: %d", rc);
		return rc;
	}

	wiringPiI2CWriteReg8(relay_fd, 1, 0);
	wiringPiI2CWriteReg8(relay_fd, 2, 0);
	wiringPiI2CWriteReg8(relay_fd, 3, 0);
	wiringPiI2CWriteReg8(relay_fd, 4, 0);

	while (IOT_Shadow_IsConnected(shadow_client) || QCLOUD_ERR_MQTT_ATTEMPTING_RECONNECT == rc ||
		   QCLOUD_ERR_MQTT_RECONNECTED == rc || QCLOUD_ERR_SUCCESS == rc)
	{

		rc = IOT_Shadow_Yield(shadow_client, 200);

		if (QCLOUD_ERR_MQTT_ATTEMPTING_RECONNECT == rc)
		{
			sleep(1);
			continue;
		}
		else if (rc != QCLOUD_ERR_SUCCESS && rc != QCLOUD_ERR_MQTT_RECONNECTED)
		{
			Log_e("exit with error: %d", rc);
			return rc;
		}

		if (relay_first_delta_arrived)
		{
			rc = IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);
			relay_first_delta_arrived = false;

			IOT_Shadow_JSON_ConstructReport(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, 1, &relay_first_shadow_property);
			IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);

			wiringPiI2CWriteReg8(relay_fd, 1, relay_first_status);

			if (rc == QCLOUD_ERR_SUCCESS)
				Log_i("shadow update success");
		}

		if (relay_second_delta_arrived)
		{
			rc = IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);
			relay_second_delta_arrived = false;

			IOT_Shadow_JSON_ConstructReport(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, 1, &relay_second_shadow_property);
			IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);
			
			wiringPiI2CWriteReg8(relay_fd, 2, relay_second_status);

			if (rc == QCLOUD_ERR_SUCCESS)
				Log_i("shadow update success");
		}

		if (relay_third_delta_arrived)
		{
			rc = IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);
			relay_third_delta_arrived = false;

			IOT_Shadow_JSON_ConstructReport(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, 1, &relay_third_shadow_property);
			IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);

			wiringPiI2CWriteReg8(relay_fd, 3, relay_third_status);

			if (rc == QCLOUD_ERR_SUCCESS)
				Log_i("shadow update success");
		}

		if (relay_fourth_delta_arrived)
		{
			rc = IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);
			relay_fourth_delta_arrived = false;

			IOT_Shadow_JSON_ConstructReport(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, 1, &relay_fourth_shadow_property);
			IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);

			wiringPiI2CWriteReg8(relay_fd, 4, relay_fourth_status);

			if (rc == QCLOUD_ERR_SUCCESS)
				Log_i("shadow update success");
		}

		if (update_require == true)
		{
			IOT_Shadow_JSON_ConstructReport(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, 1, &relay_first_shadow_property);
			IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);

			IOT_Shadow_JSON_ConstructReport(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, 1, &relay_second_shadow_property);
			IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);

			IOT_Shadow_JSON_ConstructReport(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, 1, &relay_third_shadow_property);
			IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);

			IOT_Shadow_JSON_ConstructReport(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, 1, &relay_fourth_shadow_property);
			IOT_Shadow_Update_Sync(shadow_client, sg_shadow_update_buffer, sg_shadow_update_buffersize, QCLOUD_IOT_MQTT_COMMAND_TIMEOUT);

			update_require = false;
		}
		// sleep for some time in seconds
		sleep(1);
	}

	Log_e("loop exit with error: %d", rc);

	rc = IOT_Shadow_Destroy(shadow_client);

	return rc;
}

int main()
{
	IOT_Log_Set_Level(DEBUG);

	// to avoid process crash when writing to a broken socket
	signal(SIGPIPE, SIG_IGN);

	demo_device_shadow();

	return 0;
}