8 l3 x& T1 o8 s

去年腾讯为了宣传自己针对物联网的开源操作系统TencentOS tiny，举办了一场试用活动，当时幸运获得一块，但是当时公司任务较重，一直吃灰。

板子实物就这样，没啥好介绍的，都是基础的外设，如今闲来无事，再加上众多大神完善了git库，使开发变得容易，所以索性掏出来玩一下。这次主要实现以下几个功能：
6 K* F9 ?& ?  t/ ~# C1 y) i, r在腾讯物联网平台创建项目和产品（此处为智能灯）
  p* L( u6 w! a: G通过平台控制灯
使用腾讯连连微信小程序控制灯

一.上手体验helloworld
腾讯物联网终端操作系统（TencentOS tiny）是腾讯面向物联网领域开发的实时操作系统，具有低功耗，低资源占用，模块化，安全可靠等特点，可有效提升物联网终端产品开发效率。TencentOS tiny 提供精简的 RTOS 内核，内核组件可裁剪可配置，可快速移植到多种主流 MCU 及模组芯片上。而且，基于RTOS内核提供了丰富的物联网组件，内部集成主流物联网协议栈（如 CoAP/MQTT/TLS/DTLS/LoRaWAN/NB-IoT 等），可助力物联网终端设备及业务快速接入腾讯云物联网平台。
* E: G4 Z2 ^/ \! ]) {
从仓库拉取下来后文件夹目录如下：

这里简单介绍几个主要的文件夹：
board文件夹
7 ~( }, e- L2 o. M6 I  h: }0 U0 n这个文件夹中包含了目前为止TencentOS tiny 适配的开发板合集，在测试学习的时候非常好用，基本上热门的开发板均有适配。如果自己适配了新的开发板可以在开发完成后提交合并上去，为后续的开发者提供便利，到手即用。目前已适配很多。
: {% K/ s3 f8 D" T0 W: j! I   

device文件夹
该文件夹为TencentOS tiny支持的通信模组，包括了NB-IOT,wifi，2G,4G,lora。基本满足开发需求，使用很方便。

components文件夹
3 w; E0 |9 N7 c  D( `, p8 [+ [; I( g组件文件夹，包括上云组件，文件系统，安全组件，其中上云组件集合了各种常用的上云方式：

测试第一个代码：
根据自己的开发板在encentOS-tiny\board文件夹下寻找相对应的开发板，我这里选择TencentOS_tiny_EVB_MX_Plus，进入文件夹，打开KEIL文件，打开hello_world工程。
- K% o. ^8 p6 k$ H# t- z工程结构：

主函数中初始化了开发板的外设和任务的创建启动

board_init();初始化了系统的时钟，UART，定时器和OLED的显示，所以编译烧录后可以在屏幕上显示相关信息。

hello_world.c文件主要是创建任务，以及任务之间的调用。可以在串口观察任务运行情况
4 O0 M0 t8 B3 g: b4 k8 v+ `

1. #define TASK1_STK_SIZE          1024
   
2. 
   
3. void task1(void *arg);
   1 r/ i$ @. E0 \
4. 
   ) k. R1 m8 x* O, K9 R. B
5. osThreadDef(task1, osPriorityNormal, 1, TASK1_STK_SIZE);
   
6. 
   : o1 V: h% r* X
7. #define TASK2_STK_SIZE          1024
   6 \2 X# z1 b# S5 T" [( y
8. 
   
9. void task2(void *arg);
   # @1 p9 p% m! ]( f  a
10. 
    
11. osThreadDef(task2, osPriorityNormal, 1, TASK2_STK_SIZE);
    4 b$ S7 _+ }% w5 r' i
12. 
    ; v! R2 t, m+ L3 H4 r7 o
13. #if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
    
14. 
    
15. #define TASK3_STK_SIZE          512
    
16. 
    . n* b: Y2 ?+ E# k$ L; O
17. void task3(void *arg);
    
18. 
    
19. #endif
    * b: E! V' B1 W4 l7 W! K1 N) I9 o
20. 
    
21. void task1(void *arg)
    & o7 A% k0 V0 K
22. 
    
23. {
    8 }, c) y" z/ {3 c. m4 {4 Q: B& R
24. 
    " {" f; s6 h4 G2 v2 n# _- ?
25. #if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
    $ z" f2 F9 T( g0 ]
26. 
    3 F) m( C4 |, l9 n" ~5 D
27.     osThreadId task_dyn_created;
    " t; X1 {" m$ s8 v0 M
28. 
    
29.     osThreadDynamicDef(task3, osPriorityNormal, 1, TASK3_STK_SIZE);
    % d! G# J  b5 l0 \0 d; I
30. 
    
31.     task_dyn_created = osThreadCreate(osThread(task3), NULL);
    
32. 
    
33.     int count = 0;
    4 U1 X( S  _6 O$ S+ D  n( B
34. 
    $ g6 r3 F* G& A  _( C3 V9 a; J
35. #endif
    
36. 
    
37.     while (1) {
    2 }! K9 h- L/ G# w  `- w1 M- ~
38. 
    ( w+ W& s7 y7 i! a, I
39.         printf("###I am task1\r\n");
    
40. 
    5 g7 {5 f0 t7 G: f. \
41.         osDelay(2000);
    
42. 
    2 q! i% _- o9 P* l; H0 z9 Q
43. #if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
    
44. 
    ( t, T: M: A! f( ^$ t2 |  v
45.         if (count++ == 3) {
    
46. 
    2 q5 U' H# [, s; f1 E
47.             printf("###I am task1, kill the task3(dynamic created)\r\n");
    
48. 
    " E0 J& R$ L& i2 v
49.             osThreadTerminate(task_dyn_created);
    " p0 \3 V3 @  p* T
50. 
    
51.         }
    
52. 
    
53. #endif
    1 j) t7 E- d! O
54. 
    7 W% ~, ^5 N7 M! g9 q9 v0 V5 n4 p
55.     }
    $ U4 b0 w& C" S7 i- L: f9 X
56. 
    
57. }
    
58. 
    
59. void task2(void *arg)
    
60. 
    % l) G! d; s9 L* g% g: h6 C* r
61. {
    
62. 
    
63.     while (1) {
    
64. 
    + b& o; k- {2 S
65. #if TOS_CFG_TASK_STACK_DRAUGHT_DEPTH_DETACT_EN > 0u
    , Q4 x2 {. d" H  T
66. 
    ) @4 s+ I+ H( M6 r5 }
67.         k_err_t rc;
    " l, ?0 p8 Z) a1 f# l- n3 u( z2 T: E
68. 
    0 m0 s; k( @( U0 i$ U! z  U
69.         int depth;
    
70. 
    , t" C, f! V5 k; N1 S/ H( y
71.         rc = tos_task_stack_draught_depth(K_NULL, &depth);
    
72. 
    $ m' Z* j6 N2 x) E! x7 \4 O6 o
73.         printf("%d  %d\n", rc, depth);
    + r; w% H! B* ^2 _( c
74. 
    # Y' @$ Z6 i/ h7 |1 p( q
75. #endif
    ' U& h: v5 v4 a! H3 n6 l+ [
76. 
    
77.         printf("***I am task2\r\n");
    
78. 
    
79.         osDelay(1000);
    
80. 
    
81.     }
    ! I, P6 P" v8 ^! E( R$ ~( d$ l
82. 
    + C6 X8 L$ W* W
83. }
    " Y: |, i( g+ c8 u8 G4 [
84. 
    5 H' U$ E4 s" P- c* ?  g+ s5 C" D
85. #if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
    
86. 
    
87. void task3(void *arg)
    
88. 
    
89. {
    
90. 
    - l8 D3 s7 c+ c. K
91.     while (1) {
    # q( D7 H! F3 G) ~: X3 ~
92. 
    2 h7 T: _( A0 |
93.         printf("$I am task3(dynamic created)\r\n");
    ( S/ N. ^/ A! E$ X: c% P/ X
94. 
    ( y- L. o4 i" h  ]& r! f8 m
95.         osDelay(2000);
    
96. 
    
97.     }
    
98. 
    - t# H/ a- j$ D. H7 Y# y
99. }
    
100. 
     9 z/ g# r" z: `
101. #endif
     
102. 
     $ w- U: N1 z5 j% ^. n: S
103. void application_entry(void *arg)
     
104. 
     
105. {
     $ f& A' A- L4 d# \# R/ @8 _% P3 d( }
106. 
     ) f, S# `5 s7 w; O
107.     printf("***I am task\r\n");
     
108. 
     ; h. ?5 s+ L0 X) y% O5 o6 w
109.     osThreadCreate(osThread(task1), NULL); // Create task1
     * W* W/ k9 B9 P- f$ N
110. 
     
111.     osThreadCreate(osThread(task2), NULL); // Create task2
     0 i  S& Y( e( x/ [7 o& m: j
112. 
     
113. }

复制代码

二.上云！
5 a1 l6 G4 _3 v0 e* q/ z4 s6 n: k既然是物联网操作系统，不联网那不就是耍流氓嘛！
: u: ^+ F! K6 C6 r- N因为是腾讯的物联网平台，那么针对自家的平台适配性肯定是最好的，我们就上腾讯云IoT Explorer平台。
1.云端配置
登录腾讯云物联网开发平台，登陆后点击立即使用进入产品开发界面。

1.1 新建项目
' R; y9 n5 R6 W/ W/ `1 ]选择【公共实例】或您购买的【标准企业实例】。

进入项目列表页面，单击【新建项目】。
项目名称：输入“智能灯演示”或其他名称。
1 Y& D! C; M* y) L- x项目描述：按照实际需求填写项目描述。

项目基本信息填写完成后，单击【保存】，即可完成新建项目。
$ }7 P; W0 O0 ]1 l2 E" h项目新建成功后，即可新建产品。

; b( J) X+ W4 J$ @) w1.2 产品开发
$ y$ N( Y# u% f* F8 {# P' S1 _1.2.1 新建产品进入该项目的产品列表页面，单击【新建产品】。
; M" y3 l2 ?1 G; G# i8 W% _; G在新建产品页面，填写产品基本信息。
& G$ @" K& P+ z; L* e& r* B& n, o9 v产品名称：输入“智能灯”或其他产品名称。
产品品类：选择“智慧城市”>“公共事业”>“路灯照明”。
2 }9 t7 @- M% `# d: X  t设备类型：选择“设备”。
认证方式：选择“密钥认证”。
通信方式：这里选择其他。
其他都为默认选项。

产品创建成功后便可在产品列表里面看到“智能灯”

1.2.2 完善产品
& H3 l$ |+ x& M点击产品名称进入产品配置页面
在数据模板页面系统会自动推介了标准功能，如果有需要可自行添加

数据模板是一个 JSON 格式的文件，使用数据模板协议，用户的设备需按数据模板定义要求传输设备数据到云端，并可使用基于数据模板的诸多业务功能，点击查看json可以看到上面创建功能的json格式：

1. {
   
2. 
   % b4 q; G, c, Z' \3 G
3.   "version": "1.0",
   3 m; m0 `8 c# C, b
4. 
   / U9 H9 r5 w! G! p6 J2 i
5.   "properties": [
   
6. 
   $ S9 T9 I2 e4 ]# I" \4 a, H
7.     {
   
8. 
   : W& p. @, l# f; f/ h1 {; F
9.       "id": "power_switch",
   
10. 
    
11.       "name": "电灯开关",
      M' U( l: F/ b: I* a
12. 
    5 }7 Y! W5 r' Z! x! J( Q3 P
13.       "desc": "控制电灯开灭",
    
14. 
    
15.       "required": true,
    
16. 
    
17.       "mode": "rw",
    
18. 
    
19.       "define": {
    
20. 
    4 r/ s- i3 h7 _5 m6 @6 Y
21.         "type": "bool",
    ) m5 R' t9 H. L
22. 
    
23.         "mapping": {
    
24. 
    
25.           "0": "关",
    
26. 
    & {( Q7 j1 n. L) p& e* g
27.           "1": "开"
    $ `. y! O3 P4 e6 K' T
28. 
    
29.         }
    
30. 
    ! r8 i5 h( Q% ?5 M, i6 Z2 M, Y9 I
31.       }
    
32. 
    
33.     },
    4 D% u- ?( E8 e, B) n3 Z
34. 
      e5 ^# ~  E# A
35.     {
    
36. 
    4 k# X( ^+ q- H/ G7 c9 L2 X. k2 ~
37.       "id": "brightness",
    ) u& m5 K- o8 U( @- Z! E) q
38. 
    
39.       "name": "亮度",
    / D9 V6 h& H9 V
40. 
    
41.       "desc": "灯光亮度",
    - R5 [, n/ _2 G9 W
42. 
    
43.       "mode": "rw",
    + B& Z3 O0 r, z9 n+ u
44. 
    . d2 S4 u( J- a- o" q
45.       "define": {
    5 s9 h. @/ o2 U8 L
46. 
    $ R% A- H; O0 Z" d: M
47.         "type": "int",
    
48. 
    
49.         "unit": "%",
    / ^) h- r1 P6 k1 o" Y/ D- c
50. 
    ( M  }) Y  p, \  J. @& Z( @
51.         "step": "1",
    
52. 
    
53.         "min": "0",
    . X1 H4 `9 c! C( Z/ Y
54. 
    
55.         "max": "100",
    $ j0 o& m+ D; M0 z; d
56. 
    
57.         "start": "1"
    
58. 
    
59.       }
    , }1 Y4 z  k% L  j* ]) U) x& {
60. 
    
61.     },
    
62. 
    0 Z* t7 _- k% \  J6 O4 {( ~- r6 k6 ~
63.     {
    4 l+ x% g3 |9 E5 ~/ Q  H
64. 
    
65.       "id": "color",
    ) R8 m5 a4 @( q
66. 
    " q: j; b1 q* G$ q9 i8 L2 i9 q6 h( h5 D
67.       "name": "颜色",
    
68. 
    * ^2 L, P5 I# \1 u! [
69.       "desc": "灯光颜色",
    ( a, k! r# C9 r# h% p/ F
70. 
    0 }, N" c* L4 m, e# i% M8 M
71.       "mode": "rw",
    
72. 
    
73.       "define": {
    
74. 
    : S) |2 ?3 \8 G% ^$ t
75.         "type": "enum",
    
76. 
    
77.         "mapping": {
    6 M5 e8 S2 S( f  O5 G
78. 
    
79.           "0": "Red",
    
80. 
    7 T0 Q* x$ D+ r" x; }
81.           "1": "Green",
    % Z$ m8 `, _- ~, L
82. 
    ' ~- s0 b8 ]2 o
83.           "2": "Blue"
    
84. 
    
85.         }
    3 Z" G$ Q1 e6 ^, \0 d; l1 i
86. 
    
87.       }
    . e% {0 k9 m/ o! ^) Q) j. a! O
88. 
    ( `: ^; X/ u5 x4 Z3 y. d$ V- ?
89.     },
    # Q7 p0 U- U1 X- y; x
90. 
    6 U3 i3 ^: t& e7 v  ^
91.     {
    
92. 
    ; B! D9 [& M' U7 I2 l3 Q- }+ \( P
93.       "id": "color_temp",
    ( s* S8 j+ L" o* ^: y
94. 
    
95.       "name": "色温",
    
96. 
    
97.       "desc": "灯光冷暖",
    ! C' g& c: _6 B5 s+ f8 Z4 {4 E  w
98. 
    
99.       "mode": "rw",
    5 ?' C- C* k/ V2 m( G$ Y0 ]6 I2 e
100. 
     4 `- D0 K1 J1 j; V, V
101.       "define": {
     
102. 
     3 ~# _8 f6 M3 C1 i$ k0 I; ?! p
103.         "type": "int",
     
104. 
     - c0 Y$ V' \( q3 G1 y) q, R
105.         "min": "0",
     . I8 H3 Y) B1 u5 K
106. 
     , Z6 d: O, U2 T+ w% f
107.         "max": "100",
     ) U7 h- I  s0 r: s) H0 I' S. R# E
108. 
     
109.         "start": "0",
     
110. 
     7 U# E6 z1 s  ?  ?( r  J
111.         "step": "10",
     
112. 
     / H0 j# B. T$ a6 `
113.         "unit": "%"
     
114. 
     9 h/ i5 P5 B. `1 }
115.       }
     ; S+ d2 g" J! z- g! e
116. 
     
117.     },
     4 O) S( O9 i9 w4 p" H; V7 R
118. 
     3 R: x6 {: K! h! e: Q+ v4 \
119.     {
     
120. 
     
121.       "id": "name",
       [2 i- |2 ~5 @' l  p9 o; F1 ?
122. 
     & r! }- v1 |5 B  F$ P& D& C. P
123.       "name": "灯位置名称",
     # o8 H5 z- I  X
124. 
     
125.       "desc": "灯位置名称：书房、客厅等",
     
126. 
       Q* [( T) U  a
127.       "mode": "rw",
     
128. 
     ; I- d" Q9 V- ^1 ^& H6 r
129.       "required": false,
     
130. 
     
131.       "define": {
     
132. 
     : C3 ^& B/ u! H
133.         "type": "string",
     
134. 
     8 `0 i9 x) \- q& D9 K& Y2 s
135.         "min": "0",
     7 [+ b% |4 @5 S! z% Q" T
136. 
     2 T* S' ~# b- I$ l+ q" ?
137.         "max": "64"
     
138. 
     9 W& ?' Y: w  F' w+ q! k# Y
139.       }
     + p6 e) d- l% U/ N: ^) y9 O5 q7 \) r
140. 
       R) y9 b$ @  `6 C  C
141.     }
     
142. 
     
143.   ],
     / I0 ~6 X! Z+ G( ~% ?( T; L, T
144. 
     
145.   "events": [
     
146. 
     ! h! B/ s$ v* O( _/ W6 x
147.     {
     
148. 
     2 @* E' j8 N1 L& `
149.       "id": "status_report",
     
150. 
     
151.       "name": "DeviceStatus",
     
152. 
     7 Y  E) h2 H6 o( K; C
153.       "desc": "Report the device status",
     
154. 
     1 _% }' ?: C8 Y: a6 A
155.       "type": "info",
     / }2 {+ s8 Y# x& C5 m! h9 o
156. 
     $ g: ~. N! B8 t) P+ @" l& h
157.       "required": false,
     6 m! y7 [& O) M
158. 
       _8 s: j9 W* R0 g+ I! g
159.       "params": [
     
160. 
     
161.         {
     
162. 
     / }4 H5 J$ b" Y3 c" l( ]
163.           "id": "status",
     1 Z) z  ?5 v4 A! y/ I" z9 e
164. 
     
165.           "name": "running_state",
     
166. 
     ) c' [8 G9 y4 w7 c3 C
167.           "desc": "Report current device running state",
     
168. 
     $ @3 q( F0 g. h7 |5 M* b" X/ ?
169.           "define": {
     
170. 
     
171.             "type": "bool",
     , S9 F& F* ]$ _, k! X$ p: {0 c
172. 
     
173.             "mapping": {
     . h- ?) Q( H& ~* \: n2 C) {0 S" _0 U
174. 
     " Q2 B+ `4 X9 c8 v  t3 b$ H2 q
175.               "0": "normal",
     
176. 
     
177.               "1": "fault"
     
178. 
     
179.             }
     % }. s+ q  }" q1 H
180. 
     
181.           }
     ; @$ ]! b3 h) ]4 j
182. 
     : [8 s& h5 l& V/ L
183.         },
       e* B# H  L; L$ C- K
184. 
     # o6 T$ F/ o7 Y$ F7 j
185.         {
     # O9 C3 \1 h9 E" _
186. 
     
187.           "id": "message",
     
188. 
     
189.           "name": "Message",
     . C  w- K4 L$ N4 J$ ?
190. 
     $ g/ Y7 C0 _/ t4 m8 r$ [+ F. j3 c
191.           "desc": "Some extra message",
     8 _. F1 c8 V5 R7 n: a7 N
192. 
     
193.           "define": {
     9 H4 [# w4 f4 C
194. 
     
195.             "type": "string",
     
196. 
     $ B6 h4 _  }0 \' c% e
197.             "min": "0",
     4 ?5 ?$ J' ^0 M- h
198. 
     
199.             "max": "64"
     ) V0 j) ~. N" y: \# D" V( {
200. 
     
201.           }
     . P; V& A, W& a: b
202. 
     
203.         }
     
204. 
     0 x( T) E. d  N4 q0 @! {
205. 
     
206.     },
     2 }6 U* ]# g  U
207. 
     
208.     {
     # @( A: O* G) O4 S1 Q
209. 
     ; L8 \9 Y1 c, l: |! U
210.       "id": "low_voltage",
     7 q5 j5 a; n3 f+ r3 p9 g
211. 
     ) v, `4 ~7 F7 o) L
212.       "name": "LowVoltage",
     , u. j% O4 [: ]: J7 i3 x
213. 
     . q8 u; a( Q8 @5 t/ s+ n* Y, B
214.       "desc": "Alert for device voltage is low",
     & d& F0 X9 G5 L( c/ c
215. 
     
216.       "type": "alert",
     
217. 
     , u: U7 u5 e5 c5 I8 U6 c! |: D
218.       "required": false,
     
219. 
     ) t1 {0 W3 P+ o( f
220.       "params": [
     8 O6 G1 L* |9 `9 E6 l
221. 
     
222.         {
     + Y7 X. W1 b5 V- O' F
223. 
     
224.           "id": "voltage",
       c. \' H2 s- C8 ?
225. 
     
226.           "name": "Voltage",
     
227. 
     2 u" |% z( A, J: g# S" k9 o1 g7 s
228.           "desc": "Current voltage",
     ( E  y/ I* ~6 I: W( d
229. 
     # d6 b& p1 X# u6 Y2 o
230.           "define": {
     
231. 
     $ C7 g# w9 I2 y4 A
232.             "type": "float",
     2 V3 o% B  D# V  Q+ W1 R
233. 
     
234.             "unit": "V",
     7 Q- \9 J- o3 S* j, E6 J
235. 
     
236.             "step": "1",
     
237. 
     
238.             "min": "0.0",
     
239. 
     
240.             "max": "24.0",
     
241. 
     
242.             "start": "1"
     8 c5 V. M  u- Y  u5 ?5 R/ D4 O2 W
243. 
     
244.           }
     
245. 
       `( I2 j: Y1 r, c" o7 Q8 Y! r
246.         }
     . H" J& E2 n6 o( D: c1 h0 q
247. 
     . D+ O3 X. n& q* r
248. 
     
249.     },
     
250. 
     9 x0 C8 \! H% ^
251.     {
     
252. 
     
253.       "id": "hardware_fault",
     . Y5 I2 k" \7 c- ]" }4 U  \
254. 
     
255.       "name": "Hardware_fault",
     
256. 
     * {. O8 r! U0 `: b
257.       "desc": "Report hardware fault",
     - B) C9 w; G0 N
258. 
     
259.       "type": "fault",
     4 v. X8 M  o/ t1 o0 G' \4 U
260. 
     3 _6 k1 k( N, M
261.       "required": false,
     : x1 K+ G" c8 u. B
262. 
     ; }! g  f% i4 o/ z% L
263.       "params": [
     ' t7 I3 R4 h8 c& Y% S6 O5 a
264. 
     / L5 I9 f; F) H
265.         {
     * F2 y8 j/ m/ R
266. 
     
267.           "id": "name",
     & p6 g' M$ z+ t2 o( P- y3 D- N
268. 
     
269.           "name": "Name",
     5 m& F5 {5 d5 D1 v" u2 c
270. 
     $ R+ D1 O/ ~5 y: h
271.           "desc": "Name like: memory,tf card, censors ...",
     & }% R# \* b; v$ e% U
272. 
     # q' R& P6 g  d8 ]5 J9 l
273.           "define": {
     , h% p/ {* R+ M; X8 Q3 q+ ?
274. 
     
275.             "type": "string",
     8 J0 ?5 d( Z8 y$ ~: N* Q7 w% x
276. 
     2 M. @/ ?- c0 W# ^, ^
277.             "min": "0",
     * ~4 d- C+ _6 p3 _, U; N
278. 
     8 x$ N1 p6 O( H9 y8 O6 V) M
279.             "max": "64"
     . y- W' }+ k+ e
280. 
     5 e% z  p7 G) [3 L( p
281.           }
     
282. 
     . R" s1 n4 ~6 z0 `: ]
283.         },
     
284. 
     " g5 M4 e" x; V: q+ E+ H& I2 F, a
285.         {
     
286. 
     
287.           "id": "error_code",
     # K. m& r0 }9 T* v7 S
288. 
     
289.           "name": "Error_Code",
     
290. 
     
291.           "desc": "Error code for fault",
     % P: Z' o. d( U+ x; d
292. 
     
293.           "define": {
     
294. 
     
295.             "type": "int",
     
296. 
     - u% h4 n" `$ ^: _5 J9 A
297.             "unit": "",
     3 S$ R3 V# j: j) ]. |% r. y
298. 
     
299.             "step": "1",
     : o# }0 M! O1 T' l: c. u
300. 
     . Z: o, C! {! K  i( d
301.             "min": "0",
     6 R# w6 Y- @- a; n$ E- ?
302. 
     7 ]# s" \+ Z4 |1 r+ f1 d, p# O
303.             "max": "2000",
     
304. 
     
305.             "start": "1"
     
306. 
     
307.           }
     
308. 
     + o! F( S* N& w
309.         }
     $ B% L' [  Y0 t& V
310. 
     
311. 
     
312.     }
     ' Y; a; t1 c' n0 j
313. 
     
314.   ],
     
315. 
     
316.   "actions": [
     & X4 }1 v: `. F5 k9 `. Q% C
317. 
     5 G4 K5 Q* m5 M+ p3 L
318.     {
     
319. 
     2 R+ a& K) Y$ l. I
320.       "id": "light_blink",
     
321. 
     
322.       "name": "行为测试",
     3 g& k/ s$ `: E- n0 y8 i
323. 
     $ W, I+ i% Y+ S1 T
324.       "desc": "",
     ) j( H5 _- m3 o: d# Y  w
325. 
     0 k: ?3 X$ L7 B& H7 m) }' A
326.       "input": [
     
327. 
       ^3 c" `% U( I1 K( {( V
328.         {
     
329. 
     
330.           "id": "time",
     / W9 h( d3 \; S7 n/ {$ B/ X6 x" s  [
331. 
     
332.           "name": "time",
     
333. 
     6 Q! a4 Q5 G: l
334.           "define": {
     
335. 
     . I/ K7 A4 q& f: ~0 C" p7 Q' j' m2 G$ C
336.             "type": "int",
     . Z6 Y! }! Y7 B5 R
337. 
     
338.             "min": "0",
     / e- n1 X; L5 M1 f5 G& c/ [7 D$ c% j
339. 
     6 h. R6 J! j+ ?6 \# t3 Y* ]
340.             "max": "100",
     - p! [4 X! i! |) f% Z" ?
341. 
     / ~, _8 [! _6 k8 g8 o
342.             "start": "0",
     * j0 W' y) R4 y
343. 
     . t& V8 X9 H. N9 I
344.             "step": "1",
     : X3 K- @/ A3 |7 s5 e! K' k& i
345. 
     6 O! E: B' C; Z: |9 D
346.             "unit": ""
     6 U' L8 V+ r- [# c
347. 
     
348.           }
     
349. 
     ) o5 i! h0 H; D' F% ~" Z
350.         },
     $ @4 c( N+ C$ p1 L1 j& ~
351. 
     $ \; m% D' P) V
352.         {
     
353. 
     0 R( {$ T8 N1 H
354.           "id": "color",
     
355. 
     9 }5 \; X" d  v# w: l' x  E- e: R
356.           "name": "color",
     8 \' B" @# g: _6 L7 e: `
357. 
     , {8 X( f- _% X" m+ R3 u
358.           "define": {
     
359. 
       Q* u, o$ a7 `+ O+ P
360.             "type": "enum",
     
361. 
     
362.             "mapping": {
     + ]+ I4 e! ?9 t! P" m- `  g
363. 
     
364.               "0": "red",
     
365. 
     - i1 r% ]3 @8 w$ f- U" p
366.               "1": "yellow"
     + K1 j9 P8 s. X: g% i
367. 
     
368.             }
     2 m+ D2 G- M' V) F
369. 
     
370.           }
     
371. 
     
372.         },
     $ g; E* g" X6 ]
373. 
     2 Q/ K1 c0 n/ G; u
374.         {
     
375. 
     
376.           "id": "total_time",
     
377. 
     
378.           "name": "total_time",
     
379. 
     ( N, M; Y8 P. d% X% k
380.           "define": {
     
381. 
     
382.             "type": "int",
     
383. 
     " m5 }- P5 T, X( V* g/ @6 F1 b* w3 x) T
384.             "min": "0",
     
385. 
     9 q1 E: F9 F6 U! B1 e
386.             "max": "100",
     / E) _: L5 b+ S! }
387. 
     . d1 `3 A/ M+ a$ K2 {9 e$ y6 k7 i
388.             "start": "100",
     
389. 
     
390.             "step": "1",
     
391. 
     
392.             "unit": ""
     + D1 t) c2 T# P* p1 N) [
393. 
     
394.           }
     
395. 
     
396.         },
     
397. 
     
398.         {
     
399. 
     
400.           "id": "switch",
     ! T; S9 L5 G: q3 ?9 s
401. 
     
402.           "name": "switch",
     6 v1 C! u* a' H9 c8 n; a
403. 
     
404.           "define": {
     
405. 
     6 R6 i' `, L1 }
406.             "type": "bool",
     
407. 
     
408.             "mapping": {
     ; A' _% {! ]% O, C. `: i; D/ R
409. 
     
410.               "0": "关",
     
411. 
     
412.               "1": "开"
     
413. 
     
414.             }
     
415. 
     
416.           }
     8 i2 Q% F* H3 c; H0 p) `/ {* T2 F, V
417. 
     
418.         }
     
419. 
     
420.       ],
       Q* f4 b( k% M, K# p
421. 
     / N' \+ M" n9 m; @) `
422.       "output": [
     
423. 
     
424.         {
     0 ~; ^: Q! Y9 i$ H! @
425. 
     
426.           "id": "err_code",
     
427. 
     
428.           "name": "err_code",
     ! l6 V% Y$ {, O4 _. ^
429. 
     
430.           "define": {
     - P/ U8 P6 W* C6 l9 O
431. 
     $ Y2 {4 Z9 b3 S* o) z6 [' U
432.             "type": "bool",
     % h# H2 y4 V# K* m+ l
433. 
     1 N: z1 F5 N0 F8 b
434.             "mapping": {
     
435. 
     & Z2 {4 _: s4 e5 G+ r9 D
436.               "0": "ok",
     
437. 
     8 ]" m3 S, K/ }( Y/ B
438.               "1": "error"
     
439. 
     
440.             }
     
441. 
     1 N5 }( c5 U( e3 x( v, a- T
442.           }
     5 N5 {! B7 d' r- g  m
443. 
     * v' b* |# \) k; A
444.         }
     
445. 
     
446.       ],
     7 |, p, l5 y0 t5 [# `
447. 
     
448.       "required": false
     
449. 
     3 P5 L! z/ q# N4 w' o! T
450.     }
     
451. 
     : Q& y/ o% l2 t; d; i; p
452.   ],
     
453. 
     
454.   "profile": {
     6 }. p8 Z5 a. e
455. 
     4 j+ z- W# R% R; x6 G7 B
456.     "ProductId": "4JE4PTXVC7",
     
457. 
     , u) {# [! `8 n% j
458.     "CategoryId": "141"
     
459. 
     4 R$ e% I& K# v% D: X: D
460.   }
     3 e% r0 g% |% M$ H  X: V' m" ^
461. 
     
462. }

复制代码

# j! l* n9 V1 z0 H8 r9 Y: w% h1.3 创建测试设备
完成数据模板后直接进入设备调试，其他的功能暂时用不到。
2 ~4 k" R; D7 x5 R. R; Y7 B" ]2 q在【设备调试】页面中，单击【新建设备】，设备名为 dev001：

三、开发板代码烧录
1 t' u7 G+ ~  U0 ~, }9 aTencentOS tiny项目工程中包含了explorer的demo工程，进入该目录：
复制
D:\TencentOS-tiny\board\TencentOS_tiny_EVB_MX_Plus\KEIL\qcloud_iot_explorer_sdk_data_template
) l" s$ [& i" b' b' y. ]% E( c用keil打开工程，修改以下代码：

这三个数据信息在产品dev001详情页中，点击蓝色dev001字样便可进入：

产品 ID： 将控制台的产品 ID ，复制到上图 sg_product_id。
6 @& k+ J( G6 q! u" O+ W$ S( G2 B设备名称： 将控制台的设备名称，复制到上图 sg_device_name。
$ K, d* C4 a7 L# i! g% W0 K8 \设备密钥：将控制台的设备密钥，复制到上图sg_device_secret。
" v, t& d: e( @7 I

配置wifi信息

将此处的wifi信息替换为自己的wifi信息，注意：wifi应是2.4G的wifi信号，因为ESP8266不支持5G。
编译下载到开发板。
查看设备状态
& K/ K- Q& |( K( Y0 N. M* t烧录完成后保证程序处于运行状态。进入【控制台】>【产品开发】>【设备调试】，可查看到设备 “dev001” 的状态为“上线”状态，表示 Demo 程序已成功连接上开发平台。

查看设备属性

云端控制设备
8 ?3 L8 t" l+ g  Q1 g6 S) V: S, s串口助手可看到设备一直等待平台的指令下发。

在云端平台进入设备在线调试，下发控制指令：

右侧通信日志窗口可查看指令的下发与开发板的回应。在串口助手同样可以看到收到的数据：

为了方便观察到设备受控，这里控制开发板上的灯，因为该灯只受高低电平控制，所以无法显示颜色，亮度的受控结果，这里会使用OLED来替代。
在gpio.c中先初始化PB9

在data_template_sample.c中添加控制代码：

1. static void light_change_brightness(TYPE_DEF_TEMPLATE_INT brightness)
   " ]: ]2 i3 T3 I% E
2. 
   
3. {
   " `" M5 U3 o( t% ?+ J. @! P
4. 
   6 ^- }* E' W* c2 E( x9 W! k
5.     // 作为demo，这里用oled屏字符显示来模拟灯颜色的切换
   
6. 
   
7.     // 这里应该由用户实现硬件操作代码，来改变智能灯的颜色
   
8. 
   ; k& f" g, O- N) r
9.     // 此处demo，在开发板显示屏上显示具体的颜色
   
10. 
    9 ]" o! F0 A% |/ U2 n; \) o
11.     char brightness_str[12];
    
12. 
    
13.     snprintf(brightness_str, sizeof(brightness_str), "%d", brightness);
    
14. 
    # m0 J. o1 K. p# ]5 M+ p, s* m, Y
15.     brightness_str[sizeof(brightness_str) - 1] = '\0';
    4 O" O# \1 S9 o8 K+ ^: c; G
16. 
    9 q# T3 o* W' {% Z; H  J& B
17.     OLED_ShowString(0, 2, (uint8_t *)brightness_str, 8);
    
18. 
    
19. }
    $ z6 q1 T& H* w# T: I7 M4 h- a# ^
20. 
    8 N, Z9 K" M% Q
21. static void light_power_on(void)
    
22. 
    : R% e: D. `; V- L( F2 {" V9 E
23. {
    
24. 
    ! Z8 y- E' z4 D, `
25.     // 作为demo，这里用oled屏字符显示来模拟灯颜色的切换
    
26. 
    3 t, C* k7 {# e! o
27.     OLED_Clear();
    
28. 
    4 @& D  R0 y7 [4 q6 x) \! X
29.         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_9, GPIO_PIN_SET);        
    % G2 q; \+ g; `6 j" C/ t8 `
30. 
    " Y. l6 a8 h' t( P3 [
31. }
    
32. 
    ; [! _1 O$ E+ {/ @2 h/ I
33. static void light_power_off(void)
    + @% Y. ~/ S1 t; i( |( o
34. 
    ! @( w$ W4 t9 ^1 ~6 F
35. {
    ! f% x6 [/ f+ g+ e5 M
36. 
    3 L6 Q3 y* _- l$ {" B
37.     // 作为demo，这里用oled屏字符显示来模拟灯颜色的切换
    " p/ }9 \* l: z- b) M/ z" A0 D# L
38. 
    
39.     char *info = "light off";
    
40. 
    1 A" u  N" b" h% N3 ?0 G8 S. U
41.         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_9, GPIO_PIN_RESET);        
    
42. 
    
43.     OLED_Clear();
    
44. 
    * t1 |7 m& u% @% w( C0 `
45.     OLED_ShowString(0, 0, (uint8_t *)info, 16);
    
46. 
    - i) G6 s) u$ p+ G9 g+ a- o3 j
47. }

复制代码

定义三个控制函数，用来在接收到云端数据处理后控制硬件。

1. void deal_down_stream_user_logic(void *client, ProductDataDefine   * pData)
   
2. 
   0 b) Q' I7 A" ?! }' r
3. {
   
4.     Log_d("someting about your own product logic wait to be done");
   
5. 
   
6. /
   ! k7 q- f& C/ C0 ^/ K  c, A
7. 
   
8.     char *color_name;
   , h( O' J, }% A+ \! J. S' f
9. 
   # `0 d( `  y# j( f
10.     /* 灯光颜色 */
    ) c1 O4 ~& D, j+ m5 S! }+ c
11. 
    
12.     switch (sg_ProductData.m_color) {
    " I5 [2 j) _* b; N( }7 `0 u
13.         case 0:
    5 V; R! X3 |( S" }% r8 i  @* k
14. 
    
15.             color_name = " RED ";
    : O. I2 k0 w7 P3 p  R( v
16. 
    
17.             break;
    
18. 
    
19.         case 1:
    
20. 
    1 @, Y9 M: }' b$ F. v! J* e" `) m
21.             color_name = "GREEN";
    : z( Y3 K- u; c1 V5 B# K
22. 
      _7 `0 y$ D8 ~" h1 [1 {1 O
23.             break;
    
24. 
    ) J: k1 a! l2 j# O' o7 s( u
25.         case 2:
    / q* {2 l0 ^: a8 r- R* N7 H
26. 
    & D& u" I- ]& x5 l$ X
27.             color_name = "BLUE";
    ( W1 E6 ^& R( }8 i6 @+ t
28. 
    ; V. y3 K3 a1 W' l% k' ^
29.             break;
    
30. 
    
31.     }
    
32. 
    
33.     if (sg_ProductData.m_power_switch == 1) {
    
34.         /* 灯光开启式，按照控制参数展示 */
    
35. 
    
36.         light_power_on();
    
37. 
    ) R* R& Y" c& W0 w
38.         light_change_color(color_name);
    
39. 
    4 `% ?# ~6 w# s" u  K, t
40.         light_change_brightness(sg_ProductData.m_brightness);
    
41. 
    
42.     } else {
    ; _) g7 \* ]3 U5 Y
43.         /* 灯光关闭展示 */
    / k4 s. z' [7 o: o. ^$ E
44. 
    
45.         light_power_off();
    . [1 J$ V. \. m. Y$ }7 G& b: J
46. 
    
47.     }
    6 a' X6 O' W- M, t% K' T
48. 
    
49. }

复制代码

% h/ _0 I5 [) M1 D- m; a
+ J* w# S$ b" a- k  {& r

在该函数中处理逻辑与硬件控制,当接收到云端的消息，数据已经处理封装在pdata。
! }- r/ W& M" V. Q2 {此时我们在控制台发送新的指令：

此时状态已改变:

四、使用微信连连小程序控制：
既然是物联网设备，使用网页控制显然是不符合使用习惯的，但是腾讯自己有腾讯连连小程序，那我们就体验一番：
1.进入交互开发页面;

2.进入产品展示配置，我这里使用默认的图片，点击保存。

3.面板配置，如果没有特殊要求，直接默认，点击保存。

4.保存后进入设备调试，点击二维码：

微信搜索“腾讯连连”，打开微信连连小程序，授权后在主页面点击屏幕中间的“+”图标，使用扫一扫 扫描弹出的二维码即可绑定我们的智能灯。

- \8 c+ C& P4 R6 W: ?* J% Y" w. `/ o进入智能灯，更改灯的状态，下发指令，可以看到开发板的OLED已经更新。

9 `5 u, g) ?, Q. o7 ~! k/ `8 E作者：woai32lala