【Clion开发】【一】阿里云物联网平台使用之M61开发板移植CLinkSDK

阿里云物联网平台是一个集成了设备接入、设备管理、数据安全通信、消息订阅、消息转发和数据服务（存储、分析、过滤、解析、集成等）等能力的一体化平台。向下支持连接海量设备，采集设备数据上云；向上提供云端API，服务端可通过云端SDK调用云端API将指令下发至设备端，实现远程控制

使用C语言开发产品时，您可使用物联网平台提供的C Link SDK，简化开发过程，使设备快速接入物联网平台。

CLinkSDK的使用说明、功能介绍和版本说明_物联网平台(IoT)-阿里云帮助中心 (aliyun.com)

为了使用CLinkSDK我们需要把CLinkSDK移植到设备上
1、获取CLinkSDK

• 登录物联网平台控制台。

• 进入SDK定制页面。

  
  
  

  • 在实例概览页签的全部环境下，找到对应的实例，单击实例卡片。

  • 在左侧的导航栏，单击文档与工具。

  • 在文档与工具页面的设备接入SDK区域，单击SDK定制。

    
    
    

• 在SDK定制页面，根据需求配置相关参数。然后单击开始生成，完成SDK的下载

  
  
  

如何获取CLinkSDK4.x版本_物联网平台(IoT)-阿里云帮助中心 (aliyun.com)


2、把下载的文件解压然后复制到安信可sdk的components下面

文件夹结构

3、在linksdk目录下新建CMakeLists.txt来配置编译设置

CMakeLists.txt

1. sdk_generate_library()
   
2. # 包含头文件
   
3. sdk_add_include_directories(core)
   
4. sdk_add_include_directories(core/sysdep)
   
5. sdk_add_include_directories(core/utils)
   
6. sdk_add_include_directories(components/data-model)
   
7. 
   
8. # "core/*.c"
   
9. sdk_library_add_sources(
   
10.         core/aiot_mqtt_api.c
    
11.         core/aiot_mqtt_props_api.c
    
12.         core/aiot_state_api.c
    
13. )
    
14. # "core/utils/*.c"
    
15. sdk_library_add_sources(
    
16.         core/utils/core_auth.c
    
17.         core/utils/core_diag.c
    
18.         core/utils/core_global.c
    
19.         core/utils/core_log.c
    
20.         core/utils/core_sha256.c
    
21.         core/utils/core_string.c
    
22. )
    
23. # "core/sysdep/*.c"
    
24. sdk_library_add_sources(
    
25.         core/sysdep/core_adapter.c
    
26.         core/sysdep/core_sysdep.c
    
27. )
    
28. # "portfiles/aiot_port/*.c"
    
29. sdk_library_add_sources(
    
30.         portfiles/aiot_port/freertos_port.c
    
31. 
    
32. )
    
33. # "external/*.c"
    
34. sdk_library_add_sources(
    
35.         external/ali_ca_cert.c
    
36. )</font>

复制代码

4、将linksdk添加到安信可sdk组件的CMakeLists.txt中

1. sdk_add_subdirectory_ifdef(CONFIG_LINKSDK linksdk)

复制代码

5、在移植C Link SDK过程中，需要实现的系统依赖接口及说明
移植CLinkSDK中需要实现的系统依赖接口和示例_物联网平台(IoT)-阿里云帮助中心 (aliyun.com)
以上过程可能有些复杂，但是最主要就是修改linksdk下面的freertos_port.c文件可以直接复制我修改好的文件、详细的请参考官方文档的内容

freertos_port.c

1. /* 注意：core_sysdep_network_xxx 系列依赖函数是基于posix兼容的网络api实现的，用户应根据实际的网络接口类型进行重新适配 */
   
2. //#include <stdlib.h>
   
3. //#include <stddef.h>
   
4. //#include <string.h>
   
5. //#include <unistd.h>
   
6. #include <sys/socket.h>
   
7. #include <netdb.h>
   
8. #include <errno.h>
   
9. #include <bflb_sec_trng.h>
   
10. #include "aiot_state_api.h"
    
11. #include "aiot_sysdep_api.h"
    
12. 
    
13. #include "FreeRTOS.h"
    
14. #include "task.h"
    
15. #include "semphr.h"
    
16. 
    
17. /*
    
18. *  CORE_SYSDEP_MBEDTLS_ENABLED 不是一个用户需要关心的编译开关
    
19. *
    
20. *  大多数情况下, 就保持它如下的设置即可
    
21. *  只有少数时候, SDK的用户关心对接层代码的ROM尺寸, 并且也没有选择用TLS连接服务器
    
22. *  那时才会出现, 将 CORE_SYSDEP_MBEDTLS_ENABLED 宏定义关闭的改动, 以减小对接尺寸
    
23. *
    
24. *  我们不建议去掉 #define CORE_SYSDEP_MBEDTLS_ENABLED 这行代码
    
25. *  虽然物联网平台接收TCP方式的连接, 但我们不推荐这样做, TLS是更安全的通信方式
    
26. *
    
27. */
    
28. #define CORE_SYSDEP_MBEDTLS_ENABLED
    
29. 
    
30. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
    
31. #include "mbedtls/net_sockets.h"
    
32. #include "mbedtls/ssl.h"
    
33. #include "mbedtls/ctr_drbg.h"
    
34. #include "mbedtls/debug.h"
    
35. #include "mbedtls/platform.h"
    
36. 
    
37. typedef struct {
    
38.     mbedtls_net_context net_ctx;
    
39.     mbedtls_ssl_context ssl_ctx;
    
40.     mbedtls_ssl_config  ssl_config;
    
41.     mbedtls_x509_crt    x509_server_cert;
    
42.     mbedtls_x509_crt    x509_client_cert;
    
43.     mbedtls_pk_context  x509_client_pk;
    
44. } core_sysdep_mbedtls_t;
    
45. #endif /* CORE_SYSDEP_MBEDTLS_ENABLED */
    
46. 
    
47. typedef struct {
    
48.     int fd;
    
49.     core_sysdep_socket_type_t socket_type;
    
50.     aiot_sysdep_network_cred_t *cred;
    
51.     char *host;
    
52.     uint16_t port;
    
53.     uint32_t connect_timeout_ms;
    
54. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
    
55.     core_sysdep_psk_t psk;
    
56.     core_sysdep_mbedtls_t mbedtls;
    
57. #endif
    
58. } core_network_handle_t;
    
59. 
    
60. 
    
61. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
    
62. 
    
63. static void *_core_mbedtls_calloc(size_t n, size_t size)
    
64. {
    
65.     void *buf = NULL;
    
66. 
    
67.     if (n == 0 || size == 0) {
    
68.         return NULL;
    
69.     }
    
70. 
    
71.     buf = pvPortMalloc(n * size);
    
72.     if (NULL == buf) {
    
73.         return NULL;
    
74.     } else {
    
75.         memset(buf, 0, n * size);
    
76.     }
    
77.     return buf;
    
78. }
    
79. 
    
80. #endif /* #ifdef CORE_SYSDEP_MBEDTLS_ENABLED */
    
81. 
    
82. void *core_sysdep_malloc(uint32_t size, char *name)
    
83. {
    
84.     return pvPortMalloc(size);
    
85. }
    
86. 
    
87. void core_sysdep_free(void *ptr)
    
88. {
    
89.     vPortFree(ptr);
    
90. }
    
91. 
    
92. uint64_t core_sysdep_time(void)
    
93. {
    
94.     return (uint64_t)(xTaskGetTickCount() * portTICK_RATE_MS);
    
95. }
    
96. 
    
97. void core_sysdep_sleep(uint64_t time_ms)
    
98. {
    
99.     vTaskDelay(pdMS_TO_TICKS(time_ms));
    
100. }
     
101. 
     
102. void *core_sysdep_network_init(void)
     
103. {
     
104.     core_network_handle_t *handle = NULL;
     
105. 
     
106.     handle = pvPortMalloc(sizeof(core_network_handle_t));
     
107.     if (handle == NULL) {
     
108.         return NULL;
     
109.     }
     
110.     memset(handle, 0, sizeof(core_network_handle_t));
     
111. 
     
112.     return handle;
     
113. }
     
114. 
     
115. int32_t core_sysdep_network_setopt(void *handle, core_sysdep_network_option_t option, void *data)
     
116. {
     
117.     core_network_handle_t *network_handle = (core_network_handle_t *)handle;
     
118. 
     
119.     if (handle == NULL || data == NULL) {
     
120.         return STATE_PORT_INPUT_NULL_POINTER;
     
121.     }
     
122. 
     
123.     if (option >= CORE_SYSDEP_NETWORK_MAX) {
     
124.         return STATE_PORT_INPUT_OUT_RANGE;
     
125.     }
     
126. 
     
127.     switch (option) {
     
128.         case CORE_SYSDEP_NETWORK_SOCKET_TYPE: {
     
129.             network_handle->socket_type = *(core_sysdep_socket_type_t *)data;
     
130.         }
     
131.             break;
     
132.         case CORE_SYSDEP_NETWORK_HOST: {
     
133.             network_handle->host = pvPortMalloc(strlen(data) + 1);
     
134.             if (network_handle->host == NULL) {
     
135.                 printf("malloc failed\n");
     
136.                 return STATE_PORT_MALLOC_FAILED;
     
137.             }
     
138.             memset(network_handle->host, 0, strlen(data) + 1);
     
139.             memcpy(network_handle->host, data, strlen(data));
     
140.         }
     
141.             break;
     
142.         case CORE_SYSDEP_NETWORK_PORT: {
     
143.             network_handle->port = *(uint16_t *)data;
     
144.         }
     
145.             break;
     
146.         case CORE_SYSDEP_NETWORK_CONNECT_TIMEOUT_MS: {
     
147.             network_handle->connect_timeout_ms = *(uint32_t *)data;
     
148.         }
     
149.             break;
     
150. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
151.         case CORE_SYSDEP_NETWORK_CRED: {
     
152.             network_handle->cred = pvPortMalloc(sizeof(aiot_sysdep_network_cred_t));
     
153.             if (network_handle->cred == NULL) {
     
154.                 printf("malloc failed\n");
     
155.                 return STATE_PORT_MALLOC_FAILED;
     
156.             }
     
157.             memset(network_handle->cred, 0, sizeof(aiot_sysdep_network_cred_t));
     
158.             memcpy(network_handle->cred, data, sizeof(aiot_sysdep_network_cred_t));
     
159.         }
     
160.             break;
     
161.         case CORE_SYSDEP_NETWORK_PSK: {
     
162.             core_sysdep_psk_t *psk = (core_sysdep_psk_t *)data;
     
163.             network_handle->psk.psk_id = pvPortMalloc(strlen(psk->psk_id) + 1);
     
164.             if (network_handle->psk.psk_id == NULL) {
     
165.                 printf("malloc failed\n");
     
166.                 return STATE_PORT_MALLOC_FAILED;
     
167.             }
     
168.             memset(network_handle->psk.psk_id, 0, strlen(psk->psk_id) + 1);
     
169.             memcpy(network_handle->psk.psk_id, psk->psk_id, strlen(psk->psk_id));
     
170.             network_handle->psk.psk = pvPortMalloc(strlen(psk->psk) + 1);
     
171.             if (network_handle->psk.psk == NULL) {
     
172.                 vPortFree(network_handle->psk.psk_id);
     
173.                 printf("malloc failed\n");
     
174.                 return STATE_PORT_MALLOC_FAILED;
     
175.             }
     
176.             memset(network_handle->psk.psk, 0, strlen(psk->psk) + 1);
     
177.             memcpy(network_handle->psk.psk, psk->psk, strlen(psk->psk));
     
178.         }
     
179.             break;
     
180. #endif
     
181.         default: {
     
182.             printf("unknown option\n");
     
183.         }
     
184.     }
     
185. 
     
186.     return STATE_SUCCESS;
     
187. }
     
188. 
     
189. static int32_t _core_sysdep_network_tcp_establish(core_network_handle_t *network_handle)
     
190. {
     
191.     int32_t res = STATE_SUCCESS, fd = 0;
     
192.     char service[6] = {0};
     
193.     struct addrinfo hints;
     
194.     struct addrinfo *addrInfoList = NULL, *pos = NULL;
     
195. 
     
196.     memset(&hints, 0, sizeof(struct addrinfo));
     
197.     hints.ai_family = AF_INET; /* only IPv4 */
     
198.     hints.ai_socktype = SOCK_STREAM;
     
199.     hints.ai_protocol = IPPROTO_TCP;
     
200.     hints.ai_flags = 0;
     
201.     sprintf(service, "%u", network_handle->port);
     
202. 
     
203.     printf("establish tcp connection with server(host='%s', port=[%u])\n", network_handle->host, network_handle->port);
     
204. 
     
205.     res = getaddrinfo(network_handle->host, service, &hints, &addrInfoList);
     
206.     if (res != 0) {
     
207.         printf("getaddrinfo error, errno: %d, host: %s, port: %s\n", errno, network_handle->host, service);
     
208.         return STATE_PORT_NETWORK_DNS_FAILED;
     
209.     }
     
210. 
     
211.     for (pos = addrInfoList; pos != NULL; pos = pos->ai_next) {
     
212.         if (pos->ai_family != AF_INET) {
     
213.             printf("socket type error\n");
     
214.             res = -1;
     
215.             continue;
     
216.         }
     
217. 
     
218.         fd = socket(pos->ai_family, pos->ai_socktype, pos->ai_protocol);
     
219.         if (fd < 0) {
     
220.             printf("create socket error\n");
     
221.             res = -1;
     
222.             continue;
     
223.         }
     
224. 
     
225.         if (connect(fd, pos->ai_addr, pos->ai_addrlen) == 0) {
     
226.             network_handle->fd = fd;
     
227.             res = STATE_SUCCESS;
     
228.             break;
     
229.         }
     
230. 
     
231.         close(fd);
     
232.         printf("connect error, errno: %d\n", errno);
     
233.     }
     
234. 
     
235.     if (res < 0) {
     
236.         printf("fail to establish tcp\n");
     
237.         res = STATE_PORT_NETWORK_CONNECT_FAILED;
     
238.     } else {
     
239.         printf("success to establish tcp, fd=%d\n", network_handle->fd);
     
240.         res = STATE_SUCCESS;
     
241.     }
     
242.     freeaddrinfo(addrInfoList);
     
243. 
     
244.     return res;
     
245. }
     
246. 
     
247. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
248. static void _port_uint2str(uint16_t input, char *output)
     
249. {
     
250.     uint8_t i = 0, j = 0;
     
251.     char temp[6] = {0};
     
252. 
     
253.     do {
     
254.         temp[i++] = input % 10 + '0';
     
255.     } while ((input /= 10) > 0);
     
256. 
     
257.     do {
     
258.         output[--i] = temp[j++];
     
259.     } while (i > 0);
     
260. }
     
261. 
     
262. void core_sysdep_rand(uint8_t *output, uint32_t output_len);
     
263. static int _mbedtls_random(void *handle, unsigned char *output, size_t output_len)
     
264. {
     
265.     core_sysdep_rand(output, output_len);
     
266.     return 0;
     
267. }
     
268. 
     
269. static void _mbedtls_debug(void *ctx, int level, const char *file, int line, const char *str)
     
270. {
     
271.     ((void) level);
     
272.     if (NULL != ctx) {
     
273.         printf("%s\n", str);
     
274.     }
     
275. }
     
276. 
     
277. static int32_t _core_sysdep_network_mbedtls_establish(core_network_handle_t *network_handle)
     
278. {
     
279.     int32_t res = 0;
     
280.     char port_str[6] = {0};
     
281. 
     
282. #if defined(MBEDTLS_DEBUG_C)
     
283.     mbedtls_debug_set_threshold(0);
     
284. #endif /* #if defined(MBEDTLS_DEBUG_C) */
     
285.     mbedtls_net_init(&network_handle->mbedtls.net_ctx);
     
286.     mbedtls_ssl_init(&network_handle->mbedtls.ssl_ctx);
     
287.     mbedtls_ssl_config_init(&network_handle->mbedtls.ssl_config);
     
288.     mbedtls_platform_set_calloc_free(_core_mbedtls_calloc, free);
     
289. 
     
290.     if (network_handle->cred->max_tls_fragment == 0) {
     
291.         printf("invalid max_tls_fragment parameter\n");
     
292.         return STATE_PORT_TLS_INVALID_MAX_FRAGMENT;
     
293.     }
     
294. 
     
295.     printf("establish mbedtls connection with server(host='%s', port=[%u])\n", network_handle->host, network_handle->port);
     
296. 
     
297.     _port_uint2str(network_handle->port, port_str);
     
298. 
     
299.     if (network_handle->cred->max_tls_fragment <= 512) {
     
300.         res = mbedtls_ssl_conf_max_frag_len(&network_handle->mbedtls.ssl_config, MBEDTLS_SSL_MAX_FRAG_LEN_512);
     
301.     } else if (network_handle->cred->max_tls_fragment <= 1024) {
     
302.         res = mbedtls_ssl_conf_max_frag_len(&network_handle->mbedtls.ssl_config, MBEDTLS_SSL_MAX_FRAG_LEN_1024);
     
303.     } else if (network_handle->cred->max_tls_fragment <= 2048) {
     
304.         res = mbedtls_ssl_conf_max_frag_len(&network_handle->mbedtls.ssl_config, MBEDTLS_SSL_MAX_FRAG_LEN_2048);
     
305.     } else if (network_handle->cred->max_tls_fragment <= 4096) {
     
306.         res = mbedtls_ssl_conf_max_frag_len(&network_handle->mbedtls.ssl_config, MBEDTLS_SSL_MAX_FRAG_LEN_4096);
     
307.     } else {
     
308.         res = mbedtls_ssl_conf_max_frag_len(&network_handle->mbedtls.ssl_config, MBEDTLS_SSL_MAX_FRAG_LEN_NONE);
     
309.     }
     
310. 
     
311.     if (res < 0) {
     
312.         printf("mbedtls_ssl_conf_max_frag_len error, res: -0x%04X\n", -res);
     
313.         return res;
     
314.     }
     
315. 
     
316.     res = mbedtls_net_connect(&network_handle->mbedtls.net_ctx, network_handle->host, port_str, MBEDTLS_NET_PROTO_TCP);
     
317.     if (res < 0) {
     
318.         printf("mbedtls_net_connect error, res: -0x%04X\n", -res);
     
319.         if (res == MBEDTLS_ERR_NET_UNKNOWN_HOST) {
     
320.             res = STATE_PORT_NETWORK_DNS_FAILED;
     
321.         } else if (res == MBEDTLS_ERR_NET_SOCKET_FAILED) {
     
322.             res = STATE_PORT_TLS_SOCKET_CREATE_FAILED;
     
323.         } else if (res == MBEDTLS_ERR_NET_CONNECT_FAILED) {
     
324.             res = STATE_PORT_TLS_SOCKET_CONNECT_FAILED;
     
325.         }
     
326.         return res;
     
327.     }
     
328. 
     
329.     res = mbedtls_ssl_config_defaults(&network_handle->mbedtls.ssl_config, MBEDTLS_SSL_IS_CLIENT,
     
330.                                       MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT);
     
331.     if (res < 0) {
     
332.         printf("mbedtls_ssl_config_defaults error, res: -0x%04X\n", -res);
     
333.         return res;
     
334.     }
     
335. 
     
336.     mbedtls_ssl_conf_max_version(&network_handle->mbedtls.ssl_config, MBEDTLS_SSL_MAJOR_VERSION_3,
     
337.                                  MBEDTLS_SSL_MINOR_VERSION_3);
     
338.     mbedtls_ssl_conf_min_version(&network_handle->mbedtls.ssl_config, MBEDTLS_SSL_MAJOR_VERSION_3,
     
339.                                  MBEDTLS_SSL_MINOR_VERSION_3);
     
340.     mbedtls_ssl_conf_rng(&network_handle->mbedtls.ssl_config, _mbedtls_random, NULL);
     
341.     mbedtls_ssl_conf_dbg(&network_handle->mbedtls.ssl_config, _mbedtls_debug, stdout);
     
342. 
     
343.     if (network_handle->cred->option == AIOT_SYSDEP_NETWORK_CRED_SVRCERT_CA) {
     
344.         static const int ciphersuites[1] = {MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256};
     
345.         mbedtls_ssl_conf_ciphersuites(&network_handle->mbedtls.ssl_config, ciphersuites);
     
346. 
     
347.         if (network_handle->cred->x509_server_cert == NULL && network_handle->cred->x509_server_cert_len == 0) {
     
348.             printf("invalid x509 server cert\n");
     
349.             return STATE_PORT_TLS_INVALID_SERVER_CERT;
     
350.         }
     
351.         mbedtls_x509_crt_init(&network_handle->mbedtls.x509_server_cert);
     
352. 
     
353.         res = mbedtls_x509_crt_parse(&network_handle->mbedtls.x509_server_cert,
     
354.                                      (const unsigned char *)network_handle->cred->x509_server_cert, (size_t)network_handle->cred->x509_server_cert_len + 1);
     
355.         if (res < 0) {
     
356.             printf("mbedtls_x509_crt_parse server cert error, res: -0x%04X\n", -res);
     
357.             return STATE_PORT_TLS_INVALID_SERVER_CERT;
     
358.         }
     
359. 
     
360.         if (network_handle->cred->x509_client_cert != NULL && network_handle->cred->x509_client_cert_len > 0 &&
     
361.             network_handle->cred->x509_client_privkey != NULL && network_handle->cred->x509_client_privkey_len > 0) {
     
362.             mbedtls_x509_crt_init(&network_handle->mbedtls.x509_client_cert);
     
363.             mbedtls_pk_init(&network_handle->mbedtls.x509_client_pk);
     
364.             res = mbedtls_x509_crt_parse(&network_handle->mbedtls.x509_client_cert,
     
365.                                          (const unsigned char *)network_handle->cred->x509_client_cert, (size_t)network_handle->cred->x509_client_cert_len + 1);
     
366.             if (res < 0) {
     
367.                 printf("mbedtls_x509_crt_parse client cert error, res: -0x%04X\n", -res);
     
368.                 return STATE_PORT_TLS_INVALID_CLIENT_CERT;
     
369.             }
     
370.             res = mbedtls_pk_parse_key(&network_handle->mbedtls.x509_client_pk,
     
371.                                        (const unsigned char *)network_handle->cred->x509_client_privkey,
     
372.                                        (size_t)network_handle->cred->x509_client_privkey_len + 1, NULL, 0);
     
373.             if (res < 0) {
     
374.                 printf("mbedtls_pk_parse_key client pk error, res: -0x%04X\n", -res);
     
375.                 return STATE_PORT_TLS_INVALID_CLIENT_KEY;
     
376.             }
     
377.             res = mbedtls_ssl_conf_own_cert(&network_handle->mbedtls.ssl_config, &network_handle->mbedtls.x509_client_cert,
     
378.                                             &network_handle->mbedtls.x509_client_pk);
     
379.             if (res < 0) {
     
380.                 printf("mbedtls_ssl_conf_own_cert error, res: -0x%04X\n", -res);
     
381.                 return STATE_PORT_TLS_INVALID_CLIENT_CERT;
     
382.             }
     
383.         }
     
384.         mbedtls_ssl_conf_ca_chain(&network_handle->mbedtls.ssl_config, &network_handle->mbedtls.x509_server_cert, NULL);
     
385.     } else if (network_handle->cred->option == AIOT_SYSDEP_NETWORK_CRED_SVRCERT_PSK) {
     
386. #if 0
     
387.         static const int ciphersuites[1] = {MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA};
     
388.         res = mbedtls_ssl_conf_psk(&network_handle->mbedtls.ssl_config,
     
389.                                    (const unsigned char *)network_handle->psk.psk, (size_t)strlen(network_handle->psk.psk),
     
390.                                    (const unsigned char *)network_handle->psk.psk_id, (size_t)strlen(network_handle->psk.psk_id));
     
391.         if (res < 0) {
     
392.             printf("mbedtls_ssl_conf_psk error, res = -0x%04X\n", -res);
     
393.             return STATE_PORT_TLS_CONFIG_PSK_FAILED;
     
394.         }
     
395. 
     
396.         mbedtls_ssl_conf_ciphersuites(&network_handle->mbedtls.ssl_config, ciphersuites);
     
397. #endif
     
398.         return STATE_PORT_TLS_CONFIG_PSK_FAILED;
     
399.     } else {
     
400.         printf("unsupported security option\n");
     
401.         return STATE_PORT_TLS_INVALID_CRED_OPTION;
     
402.     }
     
403. 
     
404.     res = mbedtls_ssl_setup(&network_handle->mbedtls.ssl_ctx, &network_handle->mbedtls.ssl_config);
     
405.     if (res < 0) {
     
406.         printf("mbedtls_ssl_setup error, res: -0x%04X\n", -res);
     
407.         return res;
     
408.     }
     
409. 
     
410.     mbedtls_ssl_set_bio(&network_handle->mbedtls.ssl_ctx, &network_handle->mbedtls.net_ctx, mbedtls_net_send,
     
411.                         mbedtls_net_recv, mbedtls_net_recv_timeout);
     
412.     mbedtls_ssl_conf_read_timeout(&network_handle->mbedtls.ssl_config, network_handle->connect_timeout_ms);
     
413. 
     
414.     while ((res = mbedtls_ssl_handshake(&network_handle->mbedtls.ssl_ctx)) != 0) {
     
415.         if ((res != MBEDTLS_ERR_SSL_WANT_READ) && (res != MBEDTLS_ERR_SSL_WANT_WRITE)) {
     
416.             printf("mbedtls_ssl_handshake error, res: -0x%04X\n", -res);
     
417.             if (res == MBEDTLS_ERR_SSL_INVALID_RECORD) {
     
418.                 res = STATE_PORT_TLS_INVALID_RECORD;
     
419.             } else {
     
420.                 res = STATE_PORT_TLS_INVALID_HANDSHAKE;
     
421.             }
     
422.             return res;
     
423.         }
     
424.     }
     
425. 
     
426.     res = mbedtls_ssl_get_verify_result(&network_handle->mbedtls.ssl_ctx);
     
427.     if (res < 0) {
     
428.         printf("mbedtls_ssl_get_verify_result error, res: -0x%04X\n", -res);
     
429.         return res;
     
430.     }
     
431.     return 0;
     
432. }
     
433. #endif /* #ifdef CORE_SYSDEP_MBEDTLS_ENABLED */
     
434. 
     
435. int32_t core_sysdep_network_establish(void *handle)
     
436. {
     
437.     core_network_handle_t *network_handle = (core_network_handle_t *)handle;
     
438. 
     
439.     if (handle == NULL) {
     
440.         return STATE_PORT_INPUT_NULL_POINTER;
     
441.     }
     
442. 
     
443.     if (network_handle->socket_type == CORE_SYSDEP_SOCKET_TCP_CLIENT) {
     
444.         if (network_handle->host == NULL) {
     
445.             return STATE_PORT_MISSING_HOST;
     
446.         }
     
447.         if (network_handle->cred == NULL) {
     
448.             return _core_sysdep_network_tcp_establish(network_handle);
     
449.         } else {
     
450.             if (network_handle->cred->option == AIOT_SYSDEP_NETWORK_CRED_NONE) {
     
451.                 return _core_sysdep_network_tcp_establish(network_handle);
     
452.             }
     
453. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
454.             else {
     
455.                 return _core_sysdep_network_mbedtls_establish(network_handle);
     
456.             }
     
457. #endif
     
458.         }
     
459. 
     
460.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_TCP_SERVER) {
     
461.         return STATE_PORT_TCP_SERVER_NOT_IMPLEMENT;
     
462.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_UDP_CLIENT) {
     
463.         return STATE_PORT_UDP_CLIENT_NOT_IMPLEMENT;
     
464.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_UDP_SERVER) {
     
465.         return STATE_PORT_UDP_SERVER_NOT_IMPLEMENT;
     
466.     }
     
467. 
     
468.     printf("unknown nwk type or tcp host absent\n");
     
469. 
     
470.     return STATE_PORT_NETWORK_UNKNOWN_SOCKET_TYPE;
     
471. }
     
472. 
     
473. static int32_t _core_sysdep_network_tcp_recv(core_network_handle_t *network_handle, uint8_t *buffer, uint32_t len,
     
474.                                              uint32_t timeout_ms)
     
475. {
     
476.     int res = 0;
     
477.     int32_t recv_bytes = 0;
     
478.     ssize_t recv_res = 0;
     
479.     uint64_t timestart_ms = 0, timenow_ms = 0, timeselect_ms = 0;
     
480.     fd_set recv_sets;
     
481.     struct timeval timeselect;
     
482. 
     
483.     FD_ZERO(&recv_sets);
     
484.     FD_SET(network_handle->fd, &recv_sets);
     
485. 
     
486.     /* Start Time */
     
487.     timestart_ms = core_sysdep_time();
     
488.     timenow_ms = timestart_ms;
     
489. 
     
490.     do {
     
491.         timenow_ms = core_sysdep_time();
     
492. 
     
493.         if (timenow_ms - timestart_ms >= timenow_ms ||
     
494.             timeout_ms - (timenow_ms - timestart_ms) > timeout_ms) {
     
495.             break;
     
496.         }
     
497. 
     
498.         timeselect_ms = timeout_ms - (timenow_ms - timestart_ms);
     
499.         timeselect.tv_sec = timeselect_ms / 1000;
     
500.         timeselect.tv_usec = timeselect_ms % 1000 * 1000;
     
501. 
     
502.         res = select(network_handle->fd + 1, &recv_sets, NULL, NULL, &timeselect);
     
503.         if (res == 0) {
     
504.             /* printf("_core_sysdep_network_tcp_recv, nwk select timeout\n"); */
     
505.             continue;
     
506.         } else if (res < 0) {
     
507.             printf("_core_sysdep_network_tcp_recv, errno: %d\n", errno);
     
508.             perror("_core_sysdep_network_tcp_recv, nwk select failed: ");
     
509.             return STATE_PORT_NETWORK_SELECT_FAILED;
     
510.         } else {
     
511.             if (FD_ISSET(network_handle->fd, &recv_sets)) {
     
512.                 recv_res = recv(network_handle->fd, buffer + recv_bytes, len - recv_bytes, 0);
     
513.                 if (recv_res == 0) {
     
514.                     printf("_core_sysdep_network_tcp_recv, nwk connection closed\n");
     
515.                     return STATE_PORT_NETWORK_RECV_CONNECTION_CLOSED;
     
516.                 } else if (recv_res < 0) {
     
517.                     printf("_core_sysdep_network_tcp_recv, errno: %d\n", errno);
     
518.                     perror("_core_sysdep_network_tcp_recv, nwk recv error: ");
     
519.                     if (errno == EINTR) {
     
520.                         continue;
     
521.                     }
     
522.                     return STATE_PORT_NETWORK_RECV_FAILED;
     
523.                 } else {
     
524.                     recv_bytes += recv_res;
     
525.                     /* printf("recv_bytes: %d, len: %d\n",recv_bytes,len); */
     
526.                     if (recv_bytes == len) {
     
527.                         break;
     
528.                     }
     
529.                 }
     
530.             }
     
531.         }
     
532.     } while (((timenow_ms - timestart_ms) < timeout_ms) && (recv_bytes < len));
     
533. 
     
534.     /* printf("%s: recv over\n",__FUNCTION__); */
     
535.     return recv_bytes;
     
536. }
     
537. 
     
538. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
539. static int32_t _core_sysdep_network_mbedtls_recv(core_network_handle_t *network_handle, uint8_t *buffer, uint32_t len,
     
540.                                                  uint32_t timeout_ms)
     
541. {
     
542.     int res = 0;
     
543.     int32_t recv_bytes = 0;
     
544. 
     
545.     mbedtls_ssl_conf_read_timeout(&network_handle->mbedtls.ssl_config, timeout_ms);
     
546.     do {
     
547.         res = mbedtls_ssl_read(&network_handle->mbedtls.ssl_ctx, buffer + recv_bytes, len - recv_bytes);
     
548.         if (res < 0) {
     
549.             if (res == MBEDTLS_ERR_SSL_TIMEOUT) {
     
550.                 break;
     
551.             } else if (res != MBEDTLS_ERR_SSL_WANT_READ &&
     
552.                        res != MBEDTLS_ERR_SSL_WANT_WRITE &&
     
553.                        res != MBEDTLS_ERR_SSL_CLIENT_RECONNECT) {
     
554.                 if (recv_bytes == 0) {
     
555.                     printf("mbedtls_ssl_recv error, res: -0x%04X\n", -res);
     
556.                     if (res == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) {
     
557.                         return STATE_PORT_TLS_RECV_CONNECTION_CLOSED;
     
558.                     } else if (res == MBEDTLS_ERR_SSL_INVALID_RECORD) {
     
559.                         return STATE_PORT_TLS_INVALID_RECORD;
     
560.                     } else {
     
561.                         return STATE_PORT_TLS_RECV_FAILED;
     
562.                     }
     
563.                 }
     
564.                 break;
     
565.             }
     
566.         } else if (res == 0) {
     
567.             break;
     
568.         } else {
     
569.             recv_bytes += res;
     
570.         }
     
571.     } while (recv_bytes < len);
     
572. 
     
573.     return recv_bytes;
     
574. }
     
575. #endif /* #ifdef CORE_SYSDEP_MBEDTLS_ENABLED */
     
576. 
     
577. int32_t core_sysdep_network_recv(void *handle, uint8_t *buffer, uint32_t len, uint32_t timeout_ms,
     
578.                                  core_sysdep_addr_t *addr)
     
579. {
     
580.     core_network_handle_t *network_handle = (core_network_handle_t *)handle;
     
581. 
     
582.     if (handle == NULL || buffer == NULL) {
     
583.         return STATE_PORT_INPUT_NULL_POINTER;
     
584.     }
     
585. 
     
586.     if (len == 0 || timeout_ms == 0) {
     
587.         return STATE_PORT_INPUT_OUT_RANGE;
     
588.     }
     
589. 
     
590.     if (network_handle->socket_type == CORE_SYSDEP_SOCKET_TCP_CLIENT) {
     
591.         if (network_handle->cred == NULL) {
     
592.             return _core_sysdep_network_tcp_recv(network_handle, buffer, len, timeout_ms);
     
593.         } else {
     
594.             if (network_handle->cred->option == AIOT_SYSDEP_NETWORK_CRED_NONE) {
     
595.                 return _core_sysdep_network_tcp_recv(network_handle, buffer, len, timeout_ms);
     
596.             }
     
597. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
598.             else {
     
599.                 return _core_sysdep_network_mbedtls_recv(network_handle, buffer, len, timeout_ms);
     
600.             }
     
601. #endif
     
602.         }
     
603.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_TCP_SERVER) {
     
604.         return STATE_PORT_TCP_SERVER_NOT_IMPLEMENT;
     
605.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_UDP_CLIENT) {
     
606.         return STATE_PORT_UDP_CLIENT_NOT_IMPLEMENT;
     
607.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_UDP_SERVER) {
     
608.         return STATE_PORT_UDP_SERVER_NOT_IMPLEMENT;
     
609.     }
     
610. 
     
611.     printf("unknown nwk type\n");
     
612. 
     
613.     return STATE_PORT_NETWORK_UNKNOWN_SOCKET_TYPE;
     
614. }
     
615. 
     
616. int32_t _core_sysdep_network_tcp_send(core_network_handle_t *network_handle, uint8_t *buffer, uint32_t len,
     
617.                                       uint32_t timeout_ms)
     
618. {
     
619.     int res = 0;
     
620.     int32_t send_bytes = 0;
     
621.     ssize_t send_res = 0;
     
622.     uint64_t timestart_ms = 0, timenow_ms = 0, timeselect_ms = 0;
     
623.     fd_set send_sets;
     
624.     struct timeval timeselect;
     
625. 
     
626.     FD_ZERO(&send_sets);
     
627.     FD_SET(network_handle->fd, &send_sets);
     
628. 
     
629.     /* Start Time */
     
630.     timestart_ms = core_sysdep_time();
     
631.     timenow_ms = timestart_ms;
     
632. 
     
633.     do {
     
634.         timenow_ms = core_sysdep_time();
     
635. 
     
636.         if (timenow_ms - timestart_ms >= timenow_ms ||
     
637.             timeout_ms - (timenow_ms - timestart_ms) > timeout_ms) {
     
638.             break;
     
639.         }
     
640. 
     
641.         timeselect_ms = timeout_ms - (timenow_ms - timestart_ms);
     
642.         timeselect.tv_sec = timeselect_ms / 1000;
     
643.         timeselect.tv_usec = timeselect_ms % 1000 * 1000;
     
644. 
     
645.         res = select(network_handle->fd + 1, NULL, &send_sets, NULL, &timeselect);
     
646.         if (res == 0) {
     
647.             printf("_core_sysdep_network_tcp_send, nwk select timeout\n");
     
648.             continue;
     
649.         } else if (res < 0) {
     
650.             printf("_core_sysdep_network_tcp_send, errno: %d\n", errno);
     
651.             perror("_core_sysdep_network_tcp_send, nwk select failed: ");
     
652.             return STATE_PORT_NETWORK_SELECT_FAILED;
     
653.         } else {
     
654.             if (FD_ISSET(network_handle->fd, &send_sets)) {
     
655.                 send_res = send(network_handle->fd, buffer + send_bytes, len - send_bytes, 0);
     
656.                 if (send_res == 0) {
     
657.                     printf("_core_sysdep_network_tcp_send, nwk connection closed\n");
     
658.                     return STATE_PORT_NETWORK_SEND_CONNECTION_CLOSED;
     
659.                 } else if (send_res < 0) {
     
660.                     printf("_core_sysdep_network_tcp_send, errno: %d\n", errno);
     
661.                     perror("_core_sysdep_network_tcp_send, nwk recv error: ");
     
662.                     if (errno == EINTR) {
     
663.                         continue;
     
664.                     }
     
665.                     return STATE_PORT_NETWORK_SEND_FAILED;
     
666.                 } else {
     
667.                     send_bytes += send_res;
     
668.                     if (send_bytes == len) {
     
669.                         break;
     
670.                     }
     
671.                 }
     
672.             }
     
673.         }
     
674.     } while (((timenow_ms - timestart_ms) < timeout_ms) && (send_bytes < len));
     
675. 
     
676.     return send_bytes;
     
677. }
     
678. 
     
679. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
680. int32_t _core_sysdep_network_mbedtls_send(core_network_handle_t *network_handle, uint8_t *buffer, uint32_t len,
     
681.                                           uint32_t timeout_ms)
     
682. {
     
683.     int32_t res = 0;
     
684.     int32_t send_bytes = 0;
     
685.     uint64_t timestart_ms = 0, timenow_ms = 0;
     
686.     struct timeval timeout;
     
687. 
     
688.     /* timeout */
     
689.     timeout.tv_sec = timeout_ms / 1000;
     
690.     timeout.tv_usec = (timeout_ms % 1000) * 1000;
     
691. 
     
692.     /* Start Time */
     
693.     timestart_ms = core_sysdep_time();
     
694.     timenow_ms = timestart_ms;
     
695. 
     
696.     res = setsockopt(network_handle->mbedtls.net_ctx.fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
     
697.     if (res < 0) {
     
698.         printf("setsockopt error, errno: %d\r\n", errno);
     
699.         return STATE_PORT_TLS_SEND_FAILED;
     
700.     }
     
701. 
     
702.     do {
     
703.         timenow_ms = core_sysdep_time();
     
704. 
     
705.         if (timenow_ms - timestart_ms >= timenow_ms ||
     
706.             timeout_ms - (timenow_ms - timestart_ms) > timeout_ms) {
     
707.             break;
     
708.         }
     
709. 
     
710.         res = mbedtls_ssl_write(&network_handle->mbedtls.ssl_ctx, buffer + send_bytes, len - send_bytes);
     
711.         if (res < 0) {
     
712.             if (res != MBEDTLS_ERR_SSL_WANT_READ &&
     
713.                 res != MBEDTLS_ERR_SSL_WANT_WRITE) {
     
714.                 if (send_bytes == 0) {
     
715.                     printf("mbedtls_ssl_send error, res: -0x%04X\n", -res);
     
716.                     if (res == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) {
     
717.                         return STATE_PORT_TLS_SEND_CONNECTION_CLOSED;
     
718.                     } else if (res == MBEDTLS_ERR_SSL_INVALID_RECORD) {
     
719.                         return STATE_PORT_TLS_INVALID_RECORD;
     
720.                     } else {
     
721.                         return STATE_PORT_TLS_SEND_FAILED;
     
722.                     }
     
723.                 }
     
724.                 break;
     
725.             }
     
726.         } else if (res == 0) {
     
727.             break;
     
728.         } else {
     
729.             send_bytes += res;
     
730.         }
     
731.     } while (((timenow_ms - timestart_ms) < timeout_ms) && (send_bytes < len));
     
732. 
     
733.     return send_bytes;
     
734. }
     
735. #endif /* #ifdef CORE_SYSDEP_MBEDTLS_ENABLED */
     
736. 
     
737. int32_t core_sysdep_network_send(void *handle, uint8_t *buffer, uint32_t len, uint32_t timeout_ms,
     
738.                                  core_sysdep_addr_t *addr)
     
739. {
     
740.     core_network_handle_t *network_handle = (core_network_handle_t *)handle;
     
741. 
     
742.     if (handle == NULL || buffer == NULL) {
     
743.         printf("invalid parameter\n");
     
744.         return STATE_PORT_INPUT_NULL_POINTER;
     
745.     }
     
746.     if (len == 0 || timeout_ms == 0) {
     
747.         return STATE_PORT_INPUT_OUT_RANGE;
     
748.     }
     
749. 
     
750.     if (network_handle->socket_type == CORE_SYSDEP_SOCKET_TCP_CLIENT) {
     
751.         if (network_handle->cred == NULL) {
     
752.             return _core_sysdep_network_tcp_send(network_handle, buffer, len, timeout_ms);
     
753.         } else {
     
754.             if (network_handle->cred->option == AIOT_SYSDEP_NETWORK_CRED_NONE) {
     
755.                 return _core_sysdep_network_tcp_send(network_handle, buffer, len, timeout_ms);
     
756.             }
     
757. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
758.             else {
     
759.                 return _core_sysdep_network_mbedtls_send(network_handle, buffer, len, timeout_ms);
     
760.             }
     
761. #endif
     
762.         }
     
763.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_TCP_SERVER) {
     
764.         return STATE_PORT_TCP_SERVER_NOT_IMPLEMENT;
     
765.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_UDP_CLIENT) {
     
766.         return STATE_PORT_UDP_CLIENT_NOT_IMPLEMENT;
     
767.     } else if (network_handle->socket_type == CORE_SYSDEP_SOCKET_UDP_SERVER) {
     
768.         return STATE_PORT_UDP_SERVER_NOT_IMPLEMENT;
     
769.     }
     
770. 
     
771.     printf("unknown nwk type\n");
     
772. 
     
773.     return STATE_PORT_NETWORK_UNKNOWN_SOCKET_TYPE;
     
774. }
     
775. 
     
776. static void _core_sysdep_network_tcp_disconnect(core_network_handle_t *network_handle)
     
777. {
     
778.     shutdown(network_handle->fd, 2);
     
779.     close(network_handle->fd);
     
780. }
     
781. 
     
782. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
783. static void _core_sysdep_network_mbedtls_disconnect(core_network_handle_t *network_handle)
     
784. {
     
785.     mbedtls_ssl_close_notify(&network_handle->mbedtls.ssl_ctx);
     
786.     mbedtls_net_free(&network_handle->mbedtls.net_ctx);
     
787.     if (network_handle->cred->option == AIOT_SYSDEP_NETWORK_CRED_SVRCERT_CA) {
     
788.         mbedtls_x509_crt_free(&network_handle->mbedtls.x509_server_cert);
     
789.         mbedtls_x509_crt_free(&network_handle->mbedtls.x509_client_cert);
     
790.         mbedtls_pk_free(&network_handle->mbedtls.x509_client_pk);
     
791.     }
     
792.     mbedtls_ssl_free(&network_handle->mbedtls.ssl_ctx);
     
793.     mbedtls_ssl_config_free(&network_handle->mbedtls.ssl_config);
     
794. }
     
795. #endif /* #ifdef CORE_SYSDEP_MBEDTLS_ENABLED */
     
796. 
     
797. int32_t core_sysdep_network_deinit(void **handle)
     
798. {
     
799.     core_network_handle_t *network_handle = NULL;
     
800. 
     
801.     if (handle == NULL || *handle == NULL) {
     
802.         return STATE_PORT_INPUT_NULL_POINTER;
     
803.     }
     
804. 
     
805.     network_handle = *(core_network_handle_t **)handle;
     
806. 
     
807.     /* Shutdown both send and receive operations. */
     
808.     if (network_handle->socket_type == 0 && network_handle->host != NULL) {
     
809.         if (network_handle->cred == NULL) {
     
810.             _core_sysdep_network_tcp_disconnect(network_handle);
     
811.         } else {
     
812.             if (network_handle->cred->option == AIOT_SYSDEP_NETWORK_CRED_NONE) {
     
813.                 _core_sysdep_network_tcp_disconnect(network_handle);
     
814.             }
     
815. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
816.             else {
     
817.                 _core_sysdep_network_mbedtls_disconnect(network_handle);
     
818.             }
     
819. #endif
     
820.         }
     
821.     }
     
822. 
     
823.     if (network_handle->host != NULL) {
     
824.         vPortFree(network_handle->host);
     
825.         network_handle->host = NULL;
     
826.     }
     
827.     if (network_handle->cred != NULL) {
     
828.         vPortFree(network_handle->cred);
     
829.         network_handle->cred = NULL;
     
830.     }
     
831. #ifdef CORE_SYSDEP_MBEDTLS_ENABLED
     
832.     if (network_handle->psk.psk_id != NULL) {
     
833.         vPortFree(network_handle->psk.psk_id);
     
834.         network_handle->psk.psk_id = NULL;
     
835.     }
     
836.     if (network_handle->psk.psk != NULL) {
     
837.         vPortFree(network_handle->psk.psk);
     
838.         network_handle->psk.psk = NULL;
     
839.     }
     
840. #endif
     
841. 
     
842.     vPortFree(network_handle);
     
843.     *handle = NULL;
     
844. 
     
845.     return 0;
     
846. }
     
847. 
     
848. void core_sysdep_rand(uint8_t *output, uint32_t output_len)
     
849. {
     
850.     /* 使用bl提供的硬件随机数生成接口, 仅适用于esp8266和esp32 */
     
851.     bflb_trng_readlen(output,output_len);
     
852. }
     
853. 
     
854. void *core_sysdep_mutex_init(void)
     
855. {
     
856.     return xSemaphoreCreateMutex();
     
857. }
     
858. 
     
859. void core_sysdep_mutex_lock(void *mutex)
     
860. {
     
861.     xSemaphoreTake((SemaphoreHandle_t)mutex, portMAX_DELAY);
     
862. }
     
863. 
     
864. void core_sysdep_mutex_unlock(void *mutex)
     
865. {
     
866.     xSemaphoreGive((SemaphoreHandle_t)mutex);
     
867. }
     
868. 
     
869. void core_sysdep_mutex_deinit(void **mutex)
     
870. {
     
871.     if (mutex != NULL || *mutex != NULL) {
     
872.         vSemaphoreDelete((SemaphoreHandle_t)*mutex);
     
873.         *mutex = NULL;
     
874.     }
     
875. }
     
876. 
     
877. aiot_sysdep_portfile_t g_aiot_sysdep_portfile = {
     
878.         core_sysdep_malloc,
     
879.         core_sysdep_free,
     
880.         core_sysdep_time,
     
881.         core_sysdep_sleep,
     
882.         core_sysdep_network_init,
     
883.         core_sysdep_network_setopt,
     
884.         core_sysdep_network_establish,
     
885.         core_sysdep_network_recv,
     
886.         core_sysdep_network_send,
     
887.         core_sysdep_network_deinit,
     
888.         core_sysdep_rand,
     
889.         core_sysdep_mutex_init,
     
890.         core_sysdep_mutex_lock,
     
891.         core_sysdep_mutex_unlock,
     
892.         core_sysdep_mutex_deinit
     
893. };
     

复制代码

6、项目的配置修改我这里以Project_basic为例

• 配置proj.conf文件把linksdk包含进去
  

proj.conf

1. # Aliyun c LinkSDK
   
2. set(CONFIG_LINKSDK 1)

复制代码

• 修改项目下的FreeRTOSConfig.h添加下面几行
  

FreeRTOSConfig.h

1. 
   
2. #define posixconfigENABLE_CLOCKID_T 0
   
3. #define posixconfigENABLE_MODE_T 0
   
4. #define posixconfigENABLE_TIMER_T 0
   
5. #define posixconfigENABLE_TIMESPEC 0
   
6. #define posixconfigENABLE_ITIMERSPEC 0

复制代码

7、build一下
可以看到linksdk已经生成了


编译完成也没有报错说明移植就没有啥大问题了、有问题按照报错提示改就行

8、最后主要是进行移植验证等下一个帖子讲，内容有点多还需要整理一下、主要就是阿里云物联网平台的使用、设备端的开发、扩展组件、物模型的相关使用
相关代码已经放在gitee上面可以提前看看m61sdk: 安信可m61模组sdk移植项目 (gitee.com)
写的一般，欢迎大佬指正(#^.^#)，我主要用的Clion开发的用vscode基本上也差不多
剧透一下

优秀！不错不错

赞

学习了

赞

点赞

赞