1 /*
2 * Copyright (C) 2015-2020 Alibaba Group Holding Limited
3 */
4
5 #include "blecfg_pub.h"
6
7 #include "aos/kv.h"
8
9 #include "aiot_state_api.h"
10 #include "aiot_sysdep_api.h"
11 #include "aiot_mqtt_api.h"
12 #include "aiot_dm_api.h"
13 #if (BOARD_HAAS100 == 1)
14 #include "led.h"
15 #include "cJSON.h"
16 #endif
17
18 /* 字符串长度限制 */
19 #define LIMIT_PRODUCT_KEY 32
20 #define LIMIT_DEVICE_NAME 64
21 #define LIMIT_DEVICE_SECRTE 64
22
23 typedef struct {
24 BleCfg_link_cb link_cb;
25 uint8_t product_key[LIMIT_PRODUCT_KEY];
26 uint8_t device_name[LIMIT_DEVICE_NAME];
27 uint8_t device_secret[LIMIT_DEVICE_SECRTE];
28 }device_info;
29
30 static device_info s_device_info;
31
32 extern int BleCfg_linksdk_main(char *product_key, char *device_name, char *device_secret);
33
linksdk_thread(void * arg)34 static void linksdk_thread(void *arg)
35 {
36 device_info *dev_info = &s_device_info;
37
38 printf("linksdk_thread start\r\n");
39 BleCfg_linksdk_main(dev_info->product_key, dev_info->device_name, dev_info->device_secret);
40 }
41
BleCfg_devinfo_kv_save(char * pk,char * dn,char * ds)42 static int32_t BleCfg_devinfo_kv_save(char *pk, char *dn, char *ds)
43 {
44 int32_t ret;
45 int len;
46 char product_key[LIMIT_PRODUCT_KEY];
47 char device_name[LIMIT_DEVICE_NAME];
48 char device_secret[LIMIT_DEVICE_SECRTE];
49
50 if ( pk == NULL || strlen(pk) >= LIMIT_PRODUCT_KEY
51 || dn == NULL || strlen(dn) >= LIMIT_DEVICE_NAME
52 || ds == NULL || strlen(ds) >= LIMIT_DEVICE_SECRTE ) {
53 BLECFG_LOG_ERROR("[%s]: input para error!\r\n", __func__);
54 return -1;
55 }
56
57 len = LIMIT_PRODUCT_KEY;
58 ret = aos_kv_get("product_key", product_key, &len);
59 if(ret){
60 product_key[0] = 0;
61 }
62
63 len = LIMIT_DEVICE_NAME;
64 ret = aos_kv_get("device_name", device_name, &len);
65 if(ret){
66 device_name[0] = 0;
67 }
68
69 len = LIMIT_DEVICE_SECRTE;
70 ret = aos_kv_get("device_secret", device_secret, &len);
71 if(ret){
72 device_secret[0] = 0;
73 }
74
75 if ( strcmp(product_key, pk) == 0
76 && strcmp(device_name, dn) == 0
77 && strcmp(device_secret, ds) == 0) {
78 BLECFG_LOG_INFO("[%s]: kv already saved.\r\n", __func__);
79 return -1;
80 }
81
82 ret = aos_kv_set("product_key", pk, strlen(pk) + 1, 1);
83 if ( ret ){
84 BLECFG_LOG_ERROR("[%s]: set 'product_key' fail! ret = %d\r\n", __func__, ret);
85 return ret;
86 }
87
88 ret = aos_kv_set("device_name", dn, strlen(dn) + 1, 1);
89 if ( ret ) {
90 BLECFG_LOG_ERROR("[%s]: set 'device_name' fail! ret = %d\r\n", __func__, ret);
91 return ret;
92 }
93
94 ret = aos_kv_set("device_secret", ds, strlen(ds) + 1, 1);
95 if ( ret ) {
96 BLECFG_LOG_ERROR("[%s]: set 'device_secret' fail! ret = %d\r\n", __func__, ret);
97 return ret;
98 }
99
100 return 0;
101 }
102
BleCfg_devinfo_kv_load(char * pk,char * dn,char * ds)103 static int32_t BleCfg_devinfo_kv_load(char *pk, char *dn, char *ds)
104 {
105 int32_t ret;
106 int len;
107
108 len = LIMIT_PRODUCT_KEY;
109 ret = aos_kv_get("product_key", pk, &len);
110 if(ret){
111 //BLECFG_LOG_INFO("%s: product_key not find\r\n", __func__);
112 return ret;
113 }
114 BLECFG_LOG_INFO("[%s]: product_key '%s'\r\n", __func__, pk);
115
116 len = LIMIT_DEVICE_NAME;
117 ret = aos_kv_get("device_name", dn, &len);
118 if(ret){
119 //BLECFG_LOG_INFO("%s: device_name not find\r\n", __func__);
120 return ret;
121 }
122 BLECFG_LOG_INFO("[%s]: device_name '%s'\r\n", __func__, dn);
123
124 len = LIMIT_DEVICE_SECRTE;
125 ret = aos_kv_get("device_secret", ds, &len);
126 if(ret){
127 //BLECFG_LOG_INFO("%s: device_secret not find\r\n", __func__);
128 return ret;
129 }
130 BLECFG_LOG_INFO("[%s]: device_secret '%s'\r\n", __func__, ds);
131
132 return 0;
133 }
134
BleCfg_dev_set(char * pk,char * dn,char * ds)135 BLECFG_STATE BleCfg_dev_set(char *pk, char *dn, char *ds)
136 {
137 device_info *dev_info = &s_device_info;
138
139 if ( strlen(pk) + 1 >= sizeof(dev_info->product_key)
140 || strlen(dn) + 1 >= sizeof(dev_info->device_name)
141 || strlen(ds) + 1 >= sizeof(dev_info->device_secret)) {
142 return BLECFG_COMMON_FAILED;
143 }
144
145 strncpy(dev_info->product_key, pk, sizeof(dev_info->product_key));
146 strncpy(dev_info->device_name, dn, sizeof(dev_info->device_name));
147 strncpy(dev_info->device_secret, ds, sizeof(dev_info->device_secret));
148
149 return BLECFG_SUCCESS;
150 }
151
BleCfg_dev_connect()152 BLECFG_STATE BleCfg_dev_connect()
153 {
154 int32_t ret;
155 aos_task_t task_main;
156
157 BLECFG_LOG_INFO("%s: Connecting cloud...", __func__);
158
159 /* 配网流程结束，开启linkSDK连云流程 */
160 ret = aos_task_create(&task_main, "linksdk_demo", linksdk_thread,
161 NULL, NULL, 6048, AOS_DEFAULT_APP_PRI, AOS_TASK_AUTORUN);
162 if (ret < 0) {
163 printf("create 'linksdk_demo' task failed, ret = %ld \r\n", ret);
164 }
165
166 }
167
BleCfg_dev_save()168 BLECFG_STATE BleCfg_dev_save()
169 {
170 int32_t ret;
171 device_info *dev_info = &s_device_info;
172
173 ret = BleCfg_devinfo_kv_save(dev_info->product_key, dev_info->device_name, dev_info->device_secret);
174 if ( ret != 0 ) {
175 return BLECFG_COMMON_FAILED;
176 }
177
178 return BLECFG_SUCCESS;
179 }
180
BleCfg_dev_restore()181 BLECFG_STATE BleCfg_dev_restore()
182 {
183 int32_t ret;
184 device_info *dev_info = &s_device_info;
185
186 ret = BleCfg_devinfo_kv_load(dev_info->product_key, dev_info->device_name, dev_info->device_secret);
187 if ( ret != 0 ) {
188 return BLECFG_COMMON_FAILED;
189 }
190
191 return BLECFG_SUCCESS;
192 }
193
194 /*
195 * 这个例程演示了用SDK配置MQTT参数并建立连接, 之后创建2个线程
196 *
197 * + 一个线程用于保活长连接
198 * + 一个线程用于接收消息, 并在有消息到达时进入默认的数据回调, 在连接状态变化时进入事件回调
199 *
200 * 接着演示了在MQTT连接上进行属性上报, 事件上报, 以及处理收到的属性设置, 服务调用, 取消这些代码段落的注释即可观察运行效果
201 *
202 * 需要用户关注或修改的部分, 已经用 TODO 在注释中标明
203 *
204 */
205
206 /* 位于portfiles/aiot_port文件夹下的系统适配函数集合 */
207 extern aiot_sysdep_portfile_t g_aiot_sysdep_portfile;
208
209 /* 位于external/ali_ca_cert.c中的服务器证书 */
210 extern const char *ali_ca_cert;
211
212 static uint8_t g_mqtt_process_thread_running = 0;
213 static uint8_t g_mqtt_recv_thread_running = 0;
214
215 #if (BOARD_HAAS100 == 1)
216 static int32_t s_led_state[6];
217
BleCfg_led_switch(uint32_t len,char * str)218 static void BleCfg_led_switch(uint32_t len, char *str)
219 {
220 int32_t led_id;
221 int32_t led_state;
222 cJSON *strCommand, *strLed;
223 char *led_name[] = {NULL, "HaaS100_LED_1", "HaaS100_LED_2", "HaaS100_LED_3", "HaaS100_LED_4", "HaaS100_LED_5"};
224
225 strCommand = cJSON_Parse(str); //创建JSON解析对象，返回JSON格式是否正确
226 if (!strCommand) {
227 printf("JSON格式错误:%s\n\n", cJSON_GetErrorPtr()); //输出json格式错误信息
228 return;
229 }
230
231 printf("JSON格式正确:\n%s\n\n",cJSON_Print(strCommand) );
232
233 for (led_id = 1; led_id < 6; led_id++)
234 {
235 strLed = cJSON_GetObjectItem(strCommand, led_name[led_id]); //获取name键对应的值的信息
236 if (strLed == NULL || strLed->type != cJSON_Number) {
237 continue;
238 }
239 s_led_state[led_id] = strLed->valueint;
240 if (strLed->valueint == 1) {
241 led_switch(led_id, LED_ON);
242 } else {
243 led_switch(led_id, LED_OFF);
244 }
245 break;
246 }
247
248 cJSON_Delete(strCommand);//释放内存
249 }
250
BleCfg_led_init()251 static void BleCfg_led_init()
252 {
253 memset(s_led_state, 0, sizeof(s_led_state));
254 led_switch(1, LED_OFF);
255 led_switch(2, LED_OFF);
256 led_switch(3, LED_OFF);
257 led_switch(4, LED_OFF);
258 led_switch(5, LED_OFF);
259 }
260
BleCfg_led_update(void * dm_handle)261 static void BleCfg_led_update(void *dm_handle)
262 {
263 aiot_dm_msg_t msg;
264
265 memset(&msg, 0, sizeof(aiot_dm_msg_t));
266 msg.type = AIOT_DMMSG_PROPERTY_POST;
267
268 msg.data.property_post.params = "{\"LightSwitch\": 1}";
269 aiot_dm_send(dm_handle, &msg);
270
271 msg.data.property_post.params = s_led_state[1] == 1 ? "{\"HaaS100_LED_1\": 1}" : "{\"HaaS100_LED_1\": 0}";
272 aiot_dm_send(dm_handle, &msg);
273
274 msg.data.property_post.params = s_led_state[2] == 1 ? "{\"HaaS100_LED_2\": 1}" : "{\"HaaS100_LED_2\": 0}";
275 aiot_dm_send(dm_handle, &msg);
276
277 msg.data.property_post.params = s_led_state[3] == 1 ? "{\"HaaS100_LED_3\": 1}" : "{\"HaaS100_LED_3\": 0}";
278 aiot_dm_send(dm_handle, &msg);
279
280 msg.data.property_post.params = s_led_state[4] == 1 ? "{\"HaaS100_LED_4\": 1}" : "{\"HaaS100_LED_4\": 0}";
281 aiot_dm_send(dm_handle, &msg);
282
283 msg.data.property_post.params = s_led_state[5] == 1 ? "{\"HaaS100_LED_5\": 1}" : "{\"HaaS100_LED_5\": 0}";
284 aiot_dm_send(dm_handle, &msg);
285 }
286 #endif
287
288 /* TODO: 如果要关闭日志, 就把这个函数实现为空, 如果要减少日志, 可根据code选择不打印
289 *
290 * 例如: [1577589489.033][LK-0317] mqtt_basic_demo&a13FN5TplKq
291 *
292 * 上面这条日志的code就是0317(十六进制), code值的定义见core/aiot_state_api.h
293 *
294 */
295
296 /* 日志回调函数, SDK的日志会从这里输出 */
BleCfg_state_logcb(int32_t code,char * message)297 int32_t BleCfg_state_logcb(int32_t code, char *message)
298 {
299 printf("%s", message);
300 return 0;
301 }
302
303 /* MQTT事件回调函数, 当网络连接/重连/断开时被触发, 事件定义见core/aiot_mqtt_api.h */
BleCfg_mqtt_event_handler(void * handle,const aiot_mqtt_event_t * event,void * userdata)304 void BleCfg_mqtt_event_handler(void *handle, const aiot_mqtt_event_t *event, void *userdata)
305 {
306 char *product_key;
307 char *device_name;
308 char *device_secret;
309 int32_t res;
310
311 switch (event->type) {
312 /* SDK因为用户调用了aiot_mqtt_connect()接口, 与mqtt服务器建立连接已成功 */
313 case AIOT_MQTTEVT_CONNECT: {
314 printf("AIOT_MQTTEVT_CONNECT\n");
315 if ( s_device_info.link_cb != NULL ){
316 s_device_info.link_cb();
317 }
318 break;
319 }
320
321 /* SDK因为网络状况被动断连后, 自动发起重连已成功 */
322 case AIOT_MQTTEVT_RECONNECT: {
323 printf("AIOT_MQTTEVT_RECONNECT\n");
324 break;
325 }
326
327 /* SDK因为网络的状况而被动断开了连接, network是底层读写失败, heartbeat是没有按预期得到服务端心跳应答 */
328 case AIOT_MQTTEVT_DISCONNECT: {
329 char *cause = (event->data.disconnect == AIOT_MQTTDISCONNEVT_NETWORK_DISCONNECT) ? ("network disconnect") :
330 ("heartbeat disconnect");
331 printf("AIOT_MQTTEVT_DISCONNECT: %s\n", cause);
332 break;
333 }
334
335 default: {
336
337 }
338 }
339 }
340
341 /* 执行aiot_mqtt_process的线程, 包含心跳发送和QoS1消息重发 */
BleCfg_mqtt_process_thread(void * args)342 void *BleCfg_mqtt_process_thread(void *args)
343 {
344 int32_t res = STATE_SUCCESS;
345
346 while (g_mqtt_process_thread_running) {
347 res = aiot_mqtt_process(args);
348 if (res == STATE_USER_INPUT_EXEC_DISABLED) {
349 break;
350 }
351 aos_msleep(1000);
352 }
353 return NULL;
354 }
355
356 /* 执行aiot_mqtt_recv的线程, 包含网络自动重连和从服务器收取MQTT消息 */
BleCfg_mqtt_recv_thread(void * args)357 void *BleCfg_mqtt_recv_thread(void *args)
358 {
359 int32_t res = STATE_SUCCESS;
360
361 while (g_mqtt_recv_thread_running) {
362 res = aiot_mqtt_recv(args);
363 if (res < STATE_SUCCESS) {
364 if (res == STATE_USER_INPUT_EXEC_DISABLED) {
365 break;
366 }
367 aos_msleep(1000);
368 }
369 }
370 return NULL;
371 }
372
373 /* 用户数据接收处理回调函数 */
BleCfg_dm_recv_handler(void * dm_handle,const aiot_dm_recv_t * recv,void * userdata)374 static void BleCfg_dm_recv_handler(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata)
375 {
376 printf("BleCfg_dm_recv_handler, type = %d\r\n", recv->type);
377
378 switch (recv->type) {
379
380 /* 属性上报, 事件上报, 获取期望属性值或者删除期望属性值的应答 */
381 case AIOT_DMRECV_GENERIC_REPLY: {
382 printf("msg_id = %d, code = %d, data = %.*s, message = %.*s\r\n",
383 recv->data.generic_reply.msg_id,
384 recv->data.generic_reply.code,
385 recv->data.generic_reply.data_len,
386 recv->data.generic_reply.data,
387 recv->data.generic_reply.message_len,
388 recv->data.generic_reply.message);
389 }
390 break;
391
392 /* 属性设置 */
393 case AIOT_DMRECV_PROPERTY_SET: {
394 printf("msg_id = %ld, params = %.*s\r\n",
395 (unsigned long)recv->data.property_set.msg_id,
396 recv->data.property_set.params_len,
397 recv->data.property_set.params);
398
399 #if (BOARD_HAAS100 == 1)
400 BleCfg_led_switch(recv->data.property_set.params_len, recv->data.property_set.params);
401 {
402 aiot_dm_msg_t msg;
403
404 memset(&msg, 0, sizeof(aiot_dm_msg_t));
405 msg.type = AIOT_DMMSG_PROPERTY_SET_REPLY;
406 msg.data.property_set_reply.msg_id = recv->data.property_set.msg_id;
407 msg.data.property_set_reply.code = 200;
408 msg.data.property_set_reply.data = "{}";
409 int32_t res = aiot_dm_send(dm_handle, &msg);
410 if (res < 0) {
411 printf("aiot_dm_send failed\r\n");
412 }
413 }
414 BleCfg_led_update(dm_handle);
415 #endif
416 }
417 break;
418
419 /* 异步服务调用 */
420 case AIOT_DMRECV_ASYNC_SERVICE_INVOKE: {
421 printf("msg_id = %ld, service_id = %s, params = %.*s\r\n",
422 (unsigned long)recv->data.async_service_invoke.msg_id,
423 recv->data.async_service_invoke.service_id,
424 recv->data.async_service_invoke.params_len,
425 recv->data.async_service_invoke.params);
426
427 /* TODO: 以下代码演示如何对来自云平台的异步服务调用进行应答, 用户可取消注释查看演示效果
428 *
429 * 注意: 如果用户在回调函数外进行应答, 需要自行保存msg_id, 因为回调函数入参在退出回调函数后将被SDK销毁, 不可以再访问到
430 */
431
432
433 {
434 aiot_dm_msg_t msg;
435
436 memset(&msg, 0, sizeof(aiot_dm_msg_t));
437 msg.type = AIOT_DMMSG_ASYNC_SERVICE_REPLY;
438 msg.data.async_service_reply.msg_id = recv->data.async_service_invoke.msg_id;
439 msg.data.async_service_reply.code = 200;
440 msg.data.async_service_reply.service_id = "ToggleLightSwitch";
441 msg.data.async_service_reply.data = "{\"dataA\": 20}";
442 int32_t res = aiot_dm_send(dm_handle, &msg);
443 if (res < 0) {
444 printf("aiot_dm_send failed\r\n");
445 }
446 }
447
448 }
449 break;
450
451 /* 同步服务调用 */
452 case AIOT_DMRECV_SYNC_SERVICE_INVOKE: {
453 printf("msg_id = %ld, rrpc_id = %s, service_id = %s, params = %.*s\r\n",
454 (unsigned long)recv->data.sync_service_invoke.msg_id,
455 recv->data.sync_service_invoke.rrpc_id,
456 recv->data.sync_service_invoke.service_id,
457 recv->data.sync_service_invoke.params_len,
458 recv->data.sync_service_invoke.params);
459
460 /* TODO: 以下代码演示如何对来自云平台的同步服务调用进行应答, 用户可取消注释查看演示效果
461 *
462 * 注意: 如果用户在回调函数外进行应答, 需要自行保存msg_id和rrpc_id字符串, 因为回调函数入参在退出回调函数后将被SDK销毁, 不可以再访问到
463 */
464
465 /*
466 {
467 aiot_dm_msg_t msg;
468
469 memset(&msg, 0, sizeof(aiot_dm_msg_t));
470 msg.type = AIOT_DMMSG_SYNC_SERVICE_REPLY;
471 msg.data.sync_service_reply.rrpc_id = recv->data.sync_service_invoke.rrpc_id;
472 msg.data.sync_service_reply.msg_id = recv->data.sync_service_invoke.msg_id;
473 msg.data.sync_service_reply.code = 200;
474 msg.data.sync_service_reply.service_id = "SetLightSwitchTimer";
475 msg.data.sync_service_reply.data = "{}";
476 int32_t res = aiot_dm_send(dm_handle, &msg);
477 if (res < 0) {
478 printf("aiot_dm_send failed\r\n");
479 }
480 }
481 */
482 }
483 break;
484
485 /* 下行二进制数据 */
486 case AIOT_DMRECV_RAW_DATA: {
487 printf("raw data len = %d\r\n", recv->data.raw_data.data_len);
488 /* TODO: 以下代码演示如何发送二进制格式数据, 若使用需要有相应的数据透传脚本部署在云端 */
489 /*
490 {
491 aiot_dm_msg_t msg;
492 uint8_t raw_data[] = {0x01, 0x02};
493
494 memset(&msg, 0, sizeof(aiot_dm_msg_t));
495 msg.type = AIOT_DMMSG_RAW_DATA;
496 msg.data.raw_data.data = raw_data;
497 msg.data.raw_data.data_len = sizeof(raw_data);
498 aiot_dm_send(dm_handle, &msg);
499 }
500 */
501 }
502 break;
503
504 /* 二进制格式的同步服务调用, 比单纯的二进制数据消息多了个rrpc_id */
505 case AIOT_DMRECV_RAW_SYNC_SERVICE_INVOKE: {
506 printf("raw sync service rrpc_id = %s, data_len = %d\r\n",
507 recv->data.raw_service_invoke.rrpc_id,
508 recv->data.raw_service_invoke.data_len);
509 }
510 break;
511
512 default:
513 break;
514 }
515 }
516
517 /* 属性上报函数演示 */
BleCfg_send_property_post(void * dm_handle,char * params)518 int32_t BleCfg_send_property_post(void *dm_handle, char *params)
519 {
520 aiot_dm_msg_t msg;
521
522 memset(&msg, 0, sizeof(aiot_dm_msg_t));
523 msg.type = AIOT_DMMSG_PROPERTY_POST;
524 msg.data.property_post.params = params;
525
526 return aiot_dm_send(dm_handle, &msg);
527 }
528
529 /* 事件上报函数演示 */
BleCfg_send_event_post(void * dm_handle,char * event_id,char * params)530 int32_t BleCfg_send_event_post(void *dm_handle, char *event_id, char *params)
531 {
532 aiot_dm_msg_t msg;
533
534 memset(&msg, 0, sizeof(aiot_dm_msg_t));
535 msg.type = AIOT_DMMSG_EVENT_POST;
536 msg.data.event_post.event_id = event_id;
537 msg.data.event_post.params = params;
538
539 return aiot_dm_send(dm_handle, &msg);
540 }
541
542 /* 演示了获取属性LightSwitch的期望值, 用户可将此函数加入到main函数中运行演示 */
BleCfg_send_get_desred_requset(void * dm_handle)543 int32_t BleCfg_send_get_desred_requset(void *dm_handle)
544 {
545 aiot_dm_msg_t msg;
546
547 memset(&msg, 0, sizeof(aiot_dm_msg_t));
548 msg.type = AIOT_DMMSG_GET_DESIRED;
549 msg.data.get_desired.params = "[\"LightSwitch\"]";
550
551 return aiot_dm_send(dm_handle, &msg);
552 }
553
554 /* 演示了删除属性LightSwitch的期望值, 用户可将此函数加入到main函数中运行演示 */
BleCfg_send_delete_desred_requset(void * dm_handle)555 int32_t BleCfg_send_delete_desred_requset(void *dm_handle)
556 {
557 aiot_dm_msg_t msg;
558
559 memset(&msg, 0, sizeof(aiot_dm_msg_t));
560 msg.type = AIOT_DMMSG_DELETE_DESIRED;
561 msg.data.get_desired.params = "{\"LightSwitch\":{}}";
562
563 return aiot_dm_send(dm_handle, &msg);
564 }
565
BleCfg_linksdk_main(char * product_key,char * device_name,char * device_secret)566 int BleCfg_linksdk_main(char *product_key, char *device_name, char *device_secret)
567 {
568 int32_t res = STATE_SUCCESS;
569 void *dm_handle = NULL;
570 void *mqtt_handle = NULL;
571 char *url = "iot-as-mqtt.cn-shanghai.aliyuncs.com"; /* 阿里云平台上海站点的域名后缀 */
572 char host[100] = {0}; /* 用这个数组拼接设备连接的云平台站点全地址, 规则是 ${productKey}.iot-as-mqtt.cn-shanghai.aliyuncs.com */
573 uint16_t port = 443; /* 无论设备是否使用TLS连接阿里云平台, 目的端口都是443 */
574 aiot_sysdep_network_cred_t cred; /* 安全凭据结构体, 如果要用TLS, 这个结构体中配置CA证书等参数 */
575
576 /* 配置SDK的底层依赖 */
577 aiot_sysdep_set_portfile(&g_aiot_sysdep_portfile);
578 /* 配置SDK的日志输出 */
579 aiot_state_set_logcb(BleCfg_state_logcb);
580
581 /* 创建SDK的安全凭据, 用于建立TLS连接 */
582 memset(&cred, 0, sizeof(aiot_sysdep_network_cred_t));
583 cred.option = AIOT_SYSDEP_NETWORK_CRED_SVRCERT_CA; /* 使用RSA证书校验MQTT服务端 */
584 cred.max_tls_fragment = 16384; /* 最大的分片长度为16K, 其它可选值还有4K, 2K, 1K, 0.5K */
585 cred.sni_enabled = 1; /* TLS建连时, 支持Server Name Indicator */
586 cred.x509_server_cert = ali_ca_cert; /* 用来验证MQTT服务端的RSA根证书 */
587 cred.x509_server_cert_len = strlen(ali_ca_cert); /* 用来验证MQTT服务端的RSA根证书长度 */
588
589 /* 创建1个MQTT客户端实例并内部初始化默认参数 */
590 mqtt_handle = aiot_mqtt_init();
591 if (mqtt_handle == NULL) {
592 printf("aiot_mqtt_init failed\n");
593 return -1;
594 }
595
596 snprintf(host, 100, "%s.%s", product_key, url);
597 /* 配置MQTT服务器地址 */
598 aiot_mqtt_setopt(mqtt_handle, AIOT_MQTTOPT_HOST, (void *)host);
599 /* 配置MQTT服务器端口 */
600 aiot_mqtt_setopt(mqtt_handle, AIOT_MQTTOPT_PORT, (void *)&port);
601 /* 配置设备productKey */
602 aiot_mqtt_setopt(mqtt_handle, AIOT_MQTTOPT_PRODUCT_KEY, (void *)product_key);
603 /* 配置设备deviceName */
604 aiot_mqtt_setopt(mqtt_handle, AIOT_MQTTOPT_DEVICE_NAME, (void *)device_name);
605 /* 配置设备deviceSecret */
606 aiot_mqtt_setopt(mqtt_handle, AIOT_MQTTOPT_DEVICE_SECRET, (void *)device_secret);
607 /* 配置网络连接的安全凭据, 上面已经创建好了 */
608 aiot_mqtt_setopt(mqtt_handle, AIOT_MQTTOPT_NETWORK_CRED, (void *)&cred);
609 /* 配置MQTT事件回调函数 */
610 aiot_mqtt_setopt(mqtt_handle, AIOT_MQTTOPT_EVENT_HANDLER, (void *)BleCfg_mqtt_event_handler);
611
612 /* 创建DATA-MODEL实例 */
613 dm_handle = aiot_dm_init();
614 if (dm_handle == NULL) {
615 printf("aiot_dm_init failed");
616 return -1;
617 }
618 /* 配置MQTT实例句柄 */
619 aiot_dm_setopt(dm_handle, AIOT_DMOPT_MQTT_HANDLE, mqtt_handle);
620 /* 配置消息接收处理回调函数 */
621 aiot_dm_setopt(dm_handle, AIOT_DMOPT_RECV_HANDLER, (void *)BleCfg_dm_recv_handler);
622 /* 与服务器建立MQTT连接 */
623 res = aiot_mqtt_connect(mqtt_handle);
624 if (res < STATE_SUCCESS) {
625 /* 尝试建立连接失败, 销毁MQTT实例, 回收资源 */
626 aiot_mqtt_deinit(&mqtt_handle);
627 printf("aiot_mqtt_connect failed: -0x%04X\n", -res);
628 return -1;
629 }
630
631 /* 创建一个单独的线程, 专用于执行aiot_mqtt_process, 它会自动发送心跳保活, 以及重发QoS1的未应答报文 */
632 g_mqtt_process_thread_running = 1;
633 res = aos_task_new("BleCfg_mqtt_process_thread", (void (*)(void *))BleCfg_mqtt_process_thread, mqtt_handle, 4096);
634 // res = pthread_create(&g_mqtt_process_thread, NULL, BleCfg_mqtt_process_thread, mqtt_handle);
635 if (res != 0) {
636 printf("create BleCfg_mqtt_process_thread failed: %d\n", res);
637 return -1;
638 }
639
640 /* 创建一个单独的线程用于执行aiot_mqtt_recv, 它会循环收取服务器下发的MQTT消息, 并在断线时自动重连 */
641 g_mqtt_recv_thread_running = 1;
642 res = aos_task_new("BleCfg_mqtt_recv_thread", (void (*)(void *))BleCfg_mqtt_recv_thread, mqtt_handle, 4096);
643 // res = pthread_create(&g_mqtt_recv_thread, NULL, BleCfg_mqtt_recv_thread, mqtt_handle);
644 if (res != 0) {
645 printf("create BleCfg_mqtt_recv_thread failed: %d\n", res);
646 return -1;
647 }
648
649 #if (BOARD_HAAS100 == 1)
650 BleCfg_led_update(mqtt_handle);
651 #endif
652
653 /* 主循环进入休眠 */
654 while (1) {
655 /* TODO: 以下代码演示了简单的属性上报和事件上报, 用户可取消注释观察演示效果 */
656 //BleCfg_send_property_post(dm_handle, s_led_state[1] == 1 "{\"HaaS100_LED_1\": 1}" ?: "{\"HaaS100_LED_1\": 0}");
657 //BleCfg_send_event_post(dm_handle, "Error", "{\"ErrorCode\": 0}");
658 aos_msleep(10000);
659 }
660
661 /* 断开MQTT连接, 一般不会运行到这里 */
662 res = aiot_mqtt_disconnect(mqtt_handle);
663 if (res < STATE_SUCCESS) {
664 aiot_mqtt_deinit(&mqtt_handle);
665 printf("aiot_mqtt_disconnect failed: -0x%04X\n", -res);
666 return -1;
667 }
668
669 /* 销毁DATA-MODEL实例, 一般不会运行到这里 */
670 res = aiot_dm_deinit(&dm_handle);
671 if (res < STATE_SUCCESS) {
672 printf("aiot_dm_deinit failed: -0x%04X\n", -res);
673 return -1;
674 }
675
676 /* 销毁MQTT实例, 一般不会运行到这里 */
677 res = aiot_mqtt_deinit(&mqtt_handle);
678 if (res < STATE_SUCCESS) {
679 printf("aiot_mqtt_deinit failed: -0x%04X\n", -res);
680 return -1;
681 }
682
683 g_mqtt_process_thread_running = 0;
684 g_mqtt_recv_thread_running = 0;
685
686 return 0;
687 }
688
BleCfg_linksdk_init(BleCfg_link_cb link_callback)689 BLECFG_STATE BleCfg_linksdk_init(BleCfg_link_cb link_callback)
690 {
691 memset(&s_device_info, 0, sizeof(s_device_info));
692
693 s_device_info.link_cb = link_callback;
694
695 #if (BOARD_HAAS100 == 1)
696 BleCfg_led_init();
697 #endif
698
699 return BLECFG_SUCCESS;
700 }
701
702
703