/* Device shadow demo entry */
int demo_device_shadow(char *msg_buf, char *msg_readbuf)
{
char buf[1024];
iotx_err_t rc;
iotx_conn_info_pt puser_info;
void *h_shadow;
iotx_shadow_para_t shadow_para;
/* Device AUTH */
rc = IOT_SetupConnInfo(PRODUCT_KEY, DEVICE_NAME, DEVICE_SECRET, (void **)&puser_info);
if (SUCCESS_RETURN != rc) {
SHADOW_TRACE("rc = IOT_SetupConnInfo() = %d", rc);
return rc;
}
/* Construct a device shadow */
memset(&shadow_para, 0, sizeof(iotx_shadow_para_t));
shadow_para.mqtt.port = puser_info->port;
shadow_para.mqtt.host = puser_info->host_name;
shadow_para.mqtt.client_id = puser_info->client_id;
shadow_para.mqtt.username = puser_info->username;
shadow_para.mqtt.password = puser_info->password;
shadow_para.mqtt.pub_key = puser_info->pub_key;
shadow_para.mqtt.request_timeout_ms = 2000;
shadow_para.mqtt.clean_session = 0;
shadow_para.mqtt.keepalive_interval_ms = 60000;
shadow_para.mqtt.pread_buf = msg_readbuf;
shadow_para.mqtt.read_buf_size = SHADOW_MQTT_MSGLEN;
shadow_para.mqtt.pwrite_buf = msg_buf;
shadow_para.mqtt.write_buf_size = SHADOW_MQTT_MSGLEN;
shadow_para.mqtt.handle_event.h_fp = NULL;
shadow_para.mqtt.handle_event.pcontext = NULL;
h_shadow = IOT_Shadow_Construct(&shadow_para);
if (NULL == h_shadow) {
SHADOW_TRACE("construct device shadow failed!");
return rc;
}
/* Define and add two attribute */
int32_t light = 1000, temperature = 1001;
iotx_shadow_attr_t attr_light, attr_temperature;
memset(&attr_light, 0, sizeof(iotx_shadow_attr_t));
memset(&attr_temperature, 0, sizeof(iotx_shadow_attr_t));
/* Initialize the @light attribute */
attr_light.attr_type = IOTX_SHADOW_INT32;
attr_light.mode = IOTX_SHADOW_RW;
attr_light.pattr_name = "switch";
attr_light.pattr_data = &light;
attr_light.callback = _device_shadow_cb_light;
/* Initialize the @temperature attribute */
attr_temperature.attr_type = IOTX_SHADOW_INT32;
attr_temperature.mode = IOTX_SHADOW_READONLY;
attr_temperature.pattr_name = "temperature";
attr_temperature.pattr_data = &temperature;
attr_temperature.callback = NULL;
/* Register the attribute */
/* Note that you must register the attribute you want to synchronize with cloud
* before calling IOT_Shadow_Pull() */
IOT_Shadow_RegisterAttribute(h_shadow, &attr_light);
IOT_Shadow_RegisterAttribute(h_shadow, &attr_temperature);
/* synchronize the device shadow with device shadow cloud */
IOT_Shadow_Pull(h_shadow);
do {
format_data_t format;
/* Format the attribute data */
IOT_Shadow_PushFormat_Init(h_shadow, &format, buf, 1024);
IOT_Shadow_PushFormat_Add(h_shadow, &format, &attr_temperature);
IOT_Shadow_PushFormat_Add(h_shadow, &format, &attr_light);
IOT_Shadow_PushFormat_Finalize(h_shadow, &format);
/* Update attribute data */
IOT_Shadow_Push(h_shadow, format.buf, format.offset, 10);
/* Sleep 1000 ms */
HAL_SleepMs(1000);
} while (0);
/* Delete the two attributes */
IOT_Shadow_DeleteAttribute(h_shadow, &attr_temperature);
IOT_Shadow_DeleteAttribute(h_shadow, &attr_light);
IOT_Shadow_Destroy(h_shadow);
return 0;
}
int mqtt_client(void)
{
int rc = 0, msg_len;
void *pclient;
iotx_conn_info_pt pconn_info;
iotx_mqtt_param_t mqtt_params;
iotx_mqtt_topic_info_t topic_msg;
char msg_pub[128];
char *msg_buf = NULL, *msg_readbuf = NULL;
char device_name[24];
char device_secret[64];
char topic_update[64],topic_config[64],topic_control[64],topic_state[64];
if (NULL == (msg_buf = (char *)HAL_Malloc(MSG_LEN_MAX))) {
EXAMPLE_TRACE("not enough memory");
rc = -1;
goto do_exit;
}
if (NULL == (msg_readbuf = (char *)HAL_Malloc(MSG_LEN_MAX))) {
EXAMPLE_TRACE("not enough memory");
rc = -1;
goto do_exit;
}
int fd_dv;
int rdOrWrNum;
char dvcSecretBuff[36];
getClientID(device_name);
if((fd_dv=open("./dvcSecret",O_RDWR | O_CREAT)) == -1)
{
PRINTF("open dvcSecret error");
exit(1);
}
rdOrWrNum = read(fd_dv,dvcSecretBuff,36);
dvcSecretBuff[rdOrWrNum] = '\0';
if(rdOrWrNum == -1)
{
PRINTF("read dvcSecret error");
}
if(rdOrWrNum != 32)
{
getSecret(device_secret,device_name);
lseek(fd_dv,0,SEEK_SET);
rdOrWrNum = write(fd_dv,device_secret,strlen(device_secret));
truncate("./dvcSecret", rdOrWrNum);
close(fd_dv);
}
else
{
strcpy(device_secret,dvcSecretBuff);
}
if(snprintf(topic_update, sizeof(topic_update),"/%s/%s/update", PRODUCT_KEY,device_name) < 0)
{
PRINTF("topic too long!");
return -1;
}
if(snprintf(topic_config, sizeof(topic_config),"/%s/%s/config", PRODUCT_KEY,device_name) < 0)
{
PRINTF("topic too long!");
return -1;
}
if(snprintf(topic_control, sizeof(topic_control),"/%s/%s/control", PRODUCT_KEY,device_name) < 0)
{
PRINTF("topic too long!");
return -1;
}
if(snprintf(topic_state, sizeof(topic_state),"/%s/%s/state", PRODUCT_KEY,device_name) < 0)
{
PRINTF("topic too long!");
return -1;
}
/* Device AUTH */
if (0 != IOT_SetupConnInfo(PRODUCT_KEY, device_name, device_secret, (void **)&pconn_info)) {
EXAMPLE_TRACE("AUTH request failed!");
rc = -1;
goto do_exit;
}
/* Initialize MQTT parameter */
memset(&mqtt_params, 0x0, sizeof(mqtt_params));
mqtt_params.port = pconn_info->port;
mqtt_params.host = pconn_info->host_name;
mqtt_params.client_id = pconn_info->client_id;
mqtt_params.username = pconn_info->username;
mqtt_params.password = pconn_info->password;
mqtt_params.pub_key = pconn_info->pub_key;
mqtt_params.request_timeout_ms = 2000;
mqtt_params.clean_session = 0;
mqtt_params.keepalive_interval_ms = 60000;
mqtt_params.pread_buf = msg_readbuf;
mqtt_params.read_buf_size = MSG_LEN_MAX;
mqtt_params.pwrite_buf = msg_buf;
mqtt_params.write_buf_size = MSG_LEN_MAX;
mqtt_params.handle_event.h_fp = event_handle;
mqtt_params.handle_event.pcontext = NULL;
/* Construct a MQTT client with specify parameter */
pclient = IOT_MQTT_Construct(&mqtt_params);
if (NULL == pclient) {
EXAMPLE_TRACE("MQTT construct failed");
rc = -1;
goto do_exit;
}
/* Subscribe the specific topic */
rc = IOT_MQTT_Subscribe(pclient, topic_config, IOTX_MQTT_QOS1, configArrived, NULL);
if (rc < 0) {
IOT_MQTT_Destroy(&pclient);
EXAMPLE_TRACE("IOT_MQTT_Subscribe() failed, rc = %d", rc);
rc = -1;
goto do_exit;
}
/* Subscribe the specific topic */
rc = IOT_MQTT_Subscribe(pclient, topic_update, IOTX_MQTT_QOS1, updateArrived, NULL);
if (rc < 0) {
IOT_MQTT_Destroy(&pclient);
EXAMPLE_TRACE("IOT_MQTT_Subscribe() failed, rc = %d", rc);
rc = -1;
goto do_exit;
}
/* Subscribe the specific topic */
rc = IOT_MQTT_Subscribe(pclient, topic_control, IOTX_MQTT_QOS1, controlrrived, NULL);
if (rc < 0) {
IOT_MQTT_Destroy(&pclient);
EXAMPLE_TRACE("IOT_MQTT_Subscribe() failed, rc = %d", rc);
rc = -1;
goto do_exit;
}
HAL_SleepMs(1000);
/* open the version record file*/
int fd_ver;
char rd_buf[64];
char *p = rd_buf;
int rdNum = 8;
int rRdNum = 0;
int rdSum = 0;
if((fd_ver=open("./unidoli.ver",O_RDONLY)) == -1)
{
PRINTF("open unidoli.ver error \n");
exit(1);
}
do
{
p += rRdNum;
rRdNum = read(fd_ver,p,rdNum);
if(rRdNum == -1)
{
PRINTF("read unidoli.ver error\n");
}
rdSum += rRdNum;
}
while(rRdNum == rdNum);
rd_buf[rdSum] = '\0';
close(fd_ver);
PRINTF("unidoli.ver : %s",rd_buf);
/* Initialize topic information */
memset(&topic_msg, 0x0, sizeof(iotx_mqtt_topic_info_t));
snprintf(msg_pub, sizeof(msg_pub), "{\"version\":\"%s\"}", rd_buf);
topic_msg.qos = IOTX_MQTT_QOS1;
topic_msg.retain = 0;
topic_msg.dup = 0;
topic_msg.payload = (void *)msg_pub;
topic_msg.payload_len = strlen(msg_pub);
rc = IOT_MQTT_Publish(pclient, topic_state, &topic_msg);
EXAMPLE_TRACE("rc = IOT_MQTT_Publish() = %d", rc);
do
{
if(0) //turn of loop publish
{
/* Generate topic message */
msg_len = snprintf(msg_pub, sizeof(msg_pub), "{\"attr_name\":\"temperature\", \"attr_value\":\" \"}");
if (msg_len < 0) {
EXAMPLE_TRACE("Error occur! Exit program");
rc = -1;
break;
}
topic_msg.payload = (void *)msg_pub;
topic_msg.payload_len = msg_len;
rc = IOT_MQTT_Publish(pclient, topic_state, &topic_msg);
if (rc < 0) {
EXAMPLE_TRACE("error occur when publish");
rc = -1;
break;
}
#ifdef MQTT_ID2_CRYPTO
EXAMPLE_TRACE("packet-id=%u, publish topic msg='0x%02x%02x%02x%02x'...",
(uint32_t)rc,
msg_pub[0], msg_pub[1], msg_pub[2], msg_pub[3]
);
#else
EXAMPLE_TRACE("packet-id=%u, publish topic msg=%s", (uint32_t)rc, msg_pub);
#endif
}
/* handle the MQTT packet received from TCP or SSL connection */
IOT_MQTT_Yield(pclient, 200);
} while (loop_mqtt);
loop_mqtt = 1;
IOT_MQTT_Unsubscribe(pclient, topic_config);
IOT_MQTT_Unsubscribe(pclient, topic_update);
IOT_MQTT_Unsubscribe(pclient, topic_control);
HAL_SleepMs(200);
IOT_MQTT_Destroy(&pclient);
do_exit:
if (NULL != msg_buf) {
HAL_Free(msg_buf);
}
if (NULL != msg_readbuf) {
HAL_Free(msg_readbuf);
}
return rc;
}
void* iotx_cm_cloud_conn_process(void *pclient)
{
iotx_cm_conntext_t* cm_ctx = (iotx_cm_conntext_t*)pclient;
iotx_cm_connectivity_t* connectivity = iotx_cm_find_connectivity(cm_ctx, iotx_cm_cloud_conn_get_target(), NULL);
if (NULL == cm_ctx) {
CM_ERR(cm_log_error_parameter);
return NULL;
}
log_info("enter cloud process");
while (!cm_ctx->thread_stop) {
if (NULL == connectivity) {
HAL_SleepMs(1000);
connectivity = iotx_cm_find_connectivity(cm_ctx, iotx_cm_cloud_conn_get_target(), NULL);
continue;
}
if (0 == connectivity->is_connected) {
connectivity->trigger_connected_func(cm_ctx, connectivity, NULL, NULL);
continue;
}
if (iotx_cm_process_list_get_size(cm_ctx, IOTX_CM_CONNECTIVITY_TYPE_CLOUD) > 0) {
iotx_cm_process_list_node_t* node = NULL;
if (NULL != (node = iotx_cm_process_list_pop(cm_ctx, IOTX_CM_CONNECTIVITY_TYPE_CLOUD))) {
log_info("process %d", node->type);
switch(node->type) {
case IOTX_CM_PROCESS_CLOUD_REGISTER: {
iotx_cm_process_register_t* register_pt = (iotx_cm_process_register_t*)node->msg;
if (FAIL_RETURN == iotx_cm_register_service(cm_ctx, register_pt->URI, register_pt->type, register_pt->register_func,
register_pt->user_data, register_pt->mail_box)) {
log_info("register fail");
}
LITE_free(register_pt->URI);
LITE_free(register_pt);
}
break;
case IOTX_CM_PROCESS_CLOUD_UNREGISTER: {
char* URI = (char*)node->msg;
if (FAIL_RETURN == iotx_cm_unregister_service(cm_ctx, URI)) {
log_info("unregister fail");
}
LITE_free(URI);
}
break;
case IOTX_CM_PROCESS_CLOUD_SEND: {
iotx_cm_process_send_pt send_pt = (iotx_cm_process_send_pt)node->msg;
if (FAIL_RETURN == iotx_cm_send_data(cm_ctx,
send_pt->target,
iotx_cm_find_connectivity(cm_ctx, &g_cloud_target, send_pt->conn_ctx),
send_pt->URI,
send_pt->ack_type,
send_pt->payload,
send_pt->payload_length,
send_pt->conn_ctx)) {
log_info("send fail");
}
if (send_pt->target)
LITE_free(send_pt->target);
LITE_free(send_pt);
}
break;
case IOTX_CM_PROCESS_CLOUD_DISCONNECT: {
iotx_cm_cloud_conn_disconnect_handler(cm_ctx);
}
break;
case IOTX_CM_PROCESS_CLOUD_RECONNECT: {
iotx_cm_cloud_conn_reconnect_handler(cm_ctx);
}
break;
case IOTX_CM_PROCESS_CLOUD_REGISTER_RESULT:
case IOTX_CM_PROCESS_CLOUD_UNREGISTER_RESULT: {
iotx_cm_process_register_result_pt register_pt = (iotx_cm_process_register_result_pt)node->msg;
if (register_pt->URI) iotx_cm_cloud_conn_register_handler(cm_ctx, register_pt->URI, register_pt->result, register_pt->is_register);
LITE_free(register_pt->URI);
LITE_free(register_pt);
}
break;
case IOTX_CM_PROCESS_CLOUD_NEW_DATA: {
iotx_cm_message_info_t* message_info = (iotx_cm_message_info_t*)node->msg;
iotx_cm_cloud_conn_response_handler(cm_ctx, message_info);
LITE_free(node->msg);
break;
}
default:
break;
}
iotx_cm_free_list_node(cm_ctx, node);
}
/* cloud yield */
connectivity->yield_func(connectivity, 200);
} else {
/* cloud yield */
connectivity->yield_func(connectivity, 200);
}
}
return NULL;
}
