添加服务

thong

大神们，你们好，我自己实现了一个服务和特征值，发现这个特征值能正常接收到ble助手这种通用的APP发的数据，当接收别的APP发的数据时gatt_write_cmd_ind_handler这个函数一点反应没有，不知道是什么问题？

connycommy

ydz 发表于 2015-5-28 14:48
问题找到了！    还是自己对协议栈不熟引起的， 做如下修改就可以了。

/// Full LLS Database Descrip ...

楼主是贴出的上面的代码是怎么解决问题的，能详细说明一下吗?

安安

别的APP指的是什么？这个APP是不是能够发现你所建立的服务并且对对应的特征值进行操作？

thong

安安 发表于 2015-5-13 15:49
别的APP指的是什么？这个APP是不是能够发现你所建立的服务并且对对应的特征值进行操作？

做的应用APP，可以发现服务和特征值，并且会返回写成功，就是固件这边没反应，但app没问题，因为我用TI的板子可以正常接收

安安

如果对于LightBlue等等调试用的app都可以正常读写的话，我觉得可能更大的是出现在你们自己做的app上。

thong

安安 发表于 2015-5-13 16:07
如果对于LightBlue等等调试用的app都可以正常读写的话，我觉得可能更大的是出现在你们自己做的app上。

这个APP对应的TI版本的固件已经做好了，测试正常的，不知道是不是添加的服务和特征值有问题

FireBLE_blue

用LightBlue调试，如果用LightBlue写特征值，gatt_write_cmd_ind_handler函数得不到调用，应该考虑你的固件问题；检查程序。
建议下位机调试阶段都用LightBlue 读写。

ydz

楼主我现在参照防丢器程序在自己的工程中添加了自定义的服务，可是用lightblue搜索不到自定义服务，你能帮我分析下可能的原因吗？万分感谢

FireBLE_blue

ydz 发表于 2015-5-27 11:45
楼主我现在参照防丢器程序在自己的工程中添加了自定义的服务，可是用lightblue搜索不到自定义服务，你能帮 ...

添加的过程是怎样的，都加了那些代码，结果哪里与你想的结果不符，为什么与你想的不符，描述一下吧，亲，只有描述得够详细，才有得分析。

ydz

FireBLE_blue 发表于 2015-5-27 14:28
添加的过程是怎样的，都加了那些代码，结果哪里与你想的结果不符，为什么与你想的不符，描述一下吧，亲， ...

1. 我基于 simple_periheral 工程
   
2. 在attm.h 中添加
   
3. USER_SERVICE =        0xfff1,
   
4. USER_CHARACTERISTIC,        
   
5. 
   
6. 在profile 里面添加了 test.h  test.c   test_task.h   test_task.c
   
7. test.h 文件里面的部分内容
   
8. enum
   
9. {
   
10. TEST_IDX_SVC,
    
11. 
    
12. TEST_IDX_CHAR,
    
13. TEST_IDX_DATA_VAL,
    
14. 
    
15. TEST_IDX_NB,        
    
16. };
    
17. 
    
18. struct test_env_tag
    
19. {
    
20. struct prf_con_info con_info;
    
21. uint16_t shdl;
    
22. };
    
23. 
    
24. //user Database Description
    
25. extern const struct atts_desc test_att_db[TEST_IDX_NB];
    
26. 
    
27. extern const atts_svc_desc_t test_svc;
    
28. 
    
29. extern const struct atts_char_desc test_char;
    
30. 
    
31. extern struct test_env_tag test_env;
    
32. test.c
    
33. 
    
34. const struct atts_desc test_att_db[TEST_IDX_NB] =
    
35. {
    
36. //User TEST Service Declaration
    
37. [TEST_IDX_SVC] = {USER_SERVICE, PERM(RD, ENABLE), sizeof(test_svc),
    
38. sizeof(test_svc), (uint8_t *)&test_svc},
    
39. 
    
40. //test Characteristic Declaratoin        
    
41. [TEST_IDX_CHAR] = {ATT_DECL_CHARACTERISTIC, PERM(RD, ENABLE), sizeof(test_char),
    
42. sizeof(test_char), (uint8_t *)&test_char},
    
43. 
    
44. // test Characteristic Value
    
45. [TEST_IDX_DATA_VAL] = {USER_CHARACTERISTIC, PERM(RD, ENABLE) | PERM(WR, ENABLE), sizeof(uint8_t),
    
46. 0, NULL},        
    
47. };
    
48. 
    
49. const atts_svc_desc_t test_svc = USER_SERVICE;
    
50. 
    
51. //User Service test data
    
52. const struct atts_char_desc test_char = ATTS_CHAR(ATT_CHAR_PROP_RD | ATT_CHAR_PROP_WR,
    
53. 0,
    
54. USER_CHARACTERISTIC);
    
55. 
    
56. 
    
57. 
    
58. struct test_env_tag test_env;
    
59. 
    
60. void test_init(void)
    
61. {
    
62. // Reset Environment
    
63. memset(&test_env, 0, sizeof(test_env));
    
64. 
    
65. // Register USER TEST task into kernel
    
66. task_test_desc_register();
    
67. 
    
68. ke_state_set(TASK_USER, TEST_DISABLED);
    
69. }
    
70. 
    
71. void test_disable(void)
    
72. {        
    
73. // Disable testin database
    
74. attsdb_svc_set_permission(test_env.shdl, PERM_RIGHT_DISABLE);
    
75. 
    
76. struct test_disable_ind *ind = KE_MSG_ALLOC(TEST_DISABLE_IND,
    
77. TASK_APP,
    
78. TASK_USER,//test_env.con_info.appid, TASK_USER,
    
79. test_disable_ind);
    
80. 
    
81. //Fill in data
    
82. ind->conhdl = TASK_APP;
    
83. //Send the message
    
84. ke_msg_send(ind);
    
85. 
    
86. //Go to idle state
    
87. ke_state_set(TASK_USER, TEST_IDLE);
    
88. }
    
89. 
    
90. 
    
91. test_task.h
    
92. 
    
93. 
    
94. // Maximum number of Proximity Reporter task instances
    
95. #define TEST_IDX_MAX (1)
    
96. 
    
97. // Possible states of the test task
    
98. enum
    
99. {
    
100. // Disabled State
     
101. TEST_DISABLED,
     
102. 
     
103. // Idle State
     
104. TEST_IDLE,
     
105. // Connected State
     
106. 
     
107. TEST_CONNECTED,
     
108. 
     
109. // Number of define State
     
110. TEST_STATE_MAX
     
111. };
     
112. 
     
113. // Messages for Characteristic Reporter
     
114. enum
     
115. {
     
116. // Start the Characteristic reporter
     
117. TEST_ENABLE_REQ = KE_FIRST_MSG(TASK_USER),
     
118. 
     
119. //Disable confirm
     
120. TEST_DISABLE_IND,
     
121. 
     
122. // Add Characteristic into the database
     
123. TEST_CREATE_DB_REQ,
     
124. 
     
125. // Inform APP of database creation status
     
126. TEST_CREATE_DB_CFM,
     
127. 
     
128. // Error Indicaton
     
129. TEST_ERROR_IND
     
130. };
     
131. 
     
132. 
     
133. // Parameters of the CREATE_DB_REQ message
     
134. struct test_create_db_req
     
135. {
     
136. // Indicate
     
137. uint8_t features;
     
138. };
     
139. 
     
140. // Parameters of the ENABLE_REQ message
     
141. struct test_enable_req
     
142. {
     
143. // Connection Handle
     
144. uint16_t conhdl;
     
145. // Security level
     
146. uint8_t sec_lvl;
     
147. // Saved user data to set in ATT DB
     
148. uint8_t data;
     
149. };
     
150. 
     
151. 
     
152. // Parameters of the CREATE_DB_CFM message
     
153. struct test_create_db_cfm
     
154. {
     
155. // States
     
156. uint8_t status;
     
157. };
     
158. 
     
159. // Parameters of the DISABLE_IND message
     
160. struct test_disable_ind
     
161. {
     
162. // Connection Hanle
     
163. uint16_t conhdl;
     
164. //user data
     
165. uint8_t data;
     
166. };
     
167. 
     
168. 
     
169. extern const struct ke_state_handler test_state_handler[TEST_STATE_MAX];
     
170. extern const struct ke_state_handler test_default_handler;
     
171. extern ke_state_t test_state[TEST_IDX_MAX];
     
172. 
     
173. extern void task_test_desc_register(void);
     
174. 
     
175. test_task.c
     
176. static int test_create_db_req_handler(ke_msg_id_t const msgid,
     
177. struct test_create_db_req const *param,
     
178. ke_task_id_t const dest_id,
     
179. ke_task_id_t const src_id)
     
180. {
     
181. // Databsae Creation Status
     
182. uint8_t status;
     
183. 
     
184. // Save Profile ID
     
185. test_env.con_info.prf_id = TASK_USER;
     
186. 
     
187. /*---------------------------------------------------*
     
188. * User Characteristic Creation
     
189. *---------------------------------------------------*/        
     
190. 
     
191. // Add Service Into Database
     
192. status = atts_svc_create_db(&test_env.shdl, NULL, TEST_IDX_NB, NULL,
     
193. dest_id, &test_att_db[0]);
     
194. 
     
195. if(status == ATT_ERR_NO_ERROR)
     
196. {
     
197. attsdb_svc_set_permission(test_env.shdl, PERM(SVC, DISABLE));
     
198. //If we are here, database has been fulfilled with success, go to idle state
     
199. ke_state_set(TASK_USER, TEST_IDLE);
     
200. }
     
201. 
     
202. //Send CFM to application
     
203. struct test_create_db_cfm * cfm = KE_MSG_ALLOC(TEST_CREATE_DB_CFM, src_id,
     
204. TASK_USER, test_create_db_cfm );
     
205. cfm->status = status;
     
206. ke_msg_send(cfm);
     
207. 
     
208. return (KE_MSG_CONSUMED);
     
209. }        
     
210. 
     
211. static int test_enable_req_handler(ke_msg_id_t const msgid,
     
212. struct test_enable_req const *param,
     
213. ke_task_id_t const dest_id,
     
214. ke_task_id_t const src_id)
     
215. {
     
216. 
     
217. // Keep source of message, to respond to it furture on
     
218. test_env.con_info.appid = src_id;
     
219. // Strore the connection handle for which this profile is enable
     
220. test_env.con_info.conhdl = param->conhdl;
     
221. 
     
222. // Check if the provided connection exist
     
223. if(gap_get_rec_idx(param->conhdl) == GAP_INVALID_CONIDX)
     
224. {
     
225. // The connection doesn't exist, request disallowed
     
226. prf_server_error_ind_send((prf_env_struct *)&test_env, PRF_ERR_REQ_DISALLOWED,
     
227. TEST_ERROR_IND, TEST_ENABLE_REQ);
     
228. }
     
229. else
     
230. {
     
231. 
     
232. //Enable Characteristic + Set Security Level
     
233. attsdb_svc_set_permission(test_env.shdl, param->sec_lvl);
     
234. 
     
235. //Set Characteristic specified value
     
236. attsdb_att_set_value(test_env.shdl + TEST_IDX_DATA_VAL,
     
237. sizeof(uint8_t), (uint8_t *)¶m->data);
     
238. 
     
239. // Go to Connected state
     
240. ke_state_set(TASK_USER, TEST_CONNECTED);
     
241. }
     
242. 
     
243. return (KE_MSG_CONSUMED);
     
244. }
     
245. 
     
246. 
     
247. static int gatt_write_cmd_ind_handler(ke_msg_id_t const msgid,
     
248. struct gatt_write_cmd_ind const *param,
     
249. ke_task_id_t const dest_id,
     
250. ke_task_id_t const src_id)
     
251. {
     
252. 
     
253. if(param->conhdl == test_env.con_info.conhdl)
     
254. {
     
255. if(param->handle == test_env.shdl + TEST_IDX_DATA_VAL)
     
256. {
     
257. attsdb_att_set_value(param->handle, sizeof(uint8_t), (uint8_t *)¶m->value[0]);
     
258. }
     
259. }
     
260. 
     
261. return (KE_MSG_CONSUMED);
     
262. }
     
263. 
     
264. 
     
265. static int gap_discon_cmp_evt_handler(ke_msg_id_t const msgid,
     
266. struct gap_discon_cmp_evt const *param,
     
267. ke_task_id_t const dest_id,
     
268. ke_task_id_t const src_id)
     
269. {
     
270. 
     
271. // Check Connection Handle
     
272. if(param->conhdl == test_env.con_info.conhdl)
     
273. {
     
274. // Abnormal reason - APP must alert to the level specified in the Alert Level Char.
     
275. //        if ((param->reason != CO_ERROR_REMOTE_USER_TERM_CON) &&
     
276. //        (param->reason != CO_ERROR_CON_TERM_BY_LOCAL_HOST))
     
277. //        {        
     
278. 
     
279. //        }
     
280. test_disable();
     
281. }
     
282. 
     
283. return (KE_MSG_CONSUMED);
     
284. }
     
285. 
     
286. // Disable State handler definetion
     
287. const struct ke_msg_handler test_disabled[] =
     
288. {
     
289. {TEST_CREATE_DB_REQ, (ke_msg_func_t)test_create_db_req_handler},
     
290. };
     
291. 
     
292. // Idle State handler definetion
     
293. const struct ke_msg_handler test_idle[] =
     
294. {
     
295. {TEST_ENABLE_REQ, (ke_msg_func_t)test_enable_req_handler},
     
296. };
     
297. 
     
298. // Connected State handler definition
     
299. const struct ke_msg_handler test_connected[] =
     
300. {
     
301. {GATT_WRITE_CMD_IND, (ke_msg_func_t)gatt_write_cmd_ind_handler},
     
302. };
     
303. 
     
304. // Default State handlers definition
     
305. const struct ke_msg_handler test_default_state[] =
     
306. {
     
307. {GAP_DISCON_CMP_EVT, (ke_msg_func_t)gap_discon_cmp_evt_handler},
     
308. };
     
309. 
     
310. // Specifies the mssage handler structure for every input state
     
311. const struct ke_state_handler test_state_handler[TEST_STATE_MAX] =
     
312. {
     
313. [TEST_DISABLED] = KE_STATE_HANDLER(test_disabled),
     
314. [TEST_IDLE]        = KE_STATE_HANDLER_NONE,//KE_STATE_HANDLER(test_idle),
     
315. [TEST_CONNECTED]        = KE_STATE_HANDLER(test_connected),        
     
316. };
     
317. 
     
318. // Specifies the message handlers that are common to all states
     
319. const struct ke_state_handler test_default_handler = KE_STATE_HANDLER(test_default_state);
     
320. 
     
321. // Defines the place holder for the states of all the task instances
     
322. ke_state_t test_state[TEST_IDX_MAX];
     
323. 
     
324. // Register test task into kernel
     
325. void task_test_desc_register(void)
     
326. {
     
327. struct ke_task_desc task_test_desc;
     
328. 
     
329. task_test_desc.state_handler = test_state_handler;
     
330. task_test_desc.default_handler = &test_default_handler;
     
331. task_test_desc.state = test_state;
     
332. task_test_desc.state_max = TEST_STATE_MAX;
     
333. task_test_desc.idx_max = TEST_IDX_MAX;
     
334. 
     
335. task_desc_register(TASK_USER, task_test_desc);
     
336. }
     
337. 
     
338. app 里面添加 app_test.h app_test.c  app_test_task.h app_test_task.c
     
339. app_test.c
     
340. void app_test_create_db(uint8_t features)
     
341. {
     
342. struct test_create_db_req *msg = KE_MSG_ALLOC(TEST_CREATE_DB_REQ, TASK_USER, TASK_APP,
     
343. test_create_db_req);
     
344. msg->features = features;
     
345. ke_msg_send(msg);
     
346. }
     
347. 
     
348. void app_test_enable_req(uint16_t conhdl, uint8_t sec_lvl, uint8_t data)
     
349. {
     
350. struct test_enable_req *msg = KE_MSG_ALLOC(TEST_ENABLE_REQ, TASK_USER, TASK_APP,
     
351. test_enable_req);
     
352. msg->conhdl = conhdl;
     
353. msg->sec_lvl = sec_lvl;
     
354. msg->data = data;
     
355. ke_msg_send(msg);
     
356. }
     
357. 
     
358. app_test_task.c
     
359. struct app_test_env_tag *app_test_env = &app_env.test_ev;
     
360. 
     
361. int app_test_create_db_cfm_handler(ke_msg_id_t const msgid,
     
362. struct test_create_db_cfm *param,
     
363. ke_task_id_t const dest_id,
     
364. ke_task_id_t const src_id)
     
365. {
     
366. if(param->status == ATT_ERR_NO_ERROR)
     
367. {
     
368. app_clear_local_service_flag(BLE_QPPS_SERVER_BIT);
     
369. }
     
370. 
     
371. return (KE_MSG_CONSUMED);
     
372. }
     
373. 
     
374. int app_test_disable_ind_handler(ke_msg_id_t const msgid,
     
375. struct test_disable_ind *param,
     
376. ke_task_id_t const dest_id,
     
377. ke_task_id_t const src_id)
     
378. {
     
379. app_test_env->conhdl = 0xFFFF;
     
380. app_test_env->enabled = false;
     
381. 
     
382. return (KE_MSG_CONSUMED);
     
383. }

复制代码

ydz

FireBLE_blue 发表于 2015-5-27 14:28
添加的过程是怎样的，都加了那些代码，结果哪里与你想的结果不符，为什么与你想的不符，描述一下吧，亲， ...

1. app_until.c  app_get_local_service_flag 函数添加
   
2. srv_flag |= BLE_QPPS_SERVER_BIT;
   
3. 
   
4. app_env.c 修改
   
5.     //app_set_scan_rsp_data(0);
   
6.    app_set_scan_rsp_data(BLE_QPPS_SERVER_BIT);
   
7. 
   
8. 函数 app_init(void)  添加
   
9. app_test_init();
   
10. 
    
11. static void app_test_init(void)
    
12. {
    
13.         app_test_env->conhdl = 0xFFFF;
    
14. }
    
15. 
    
16. prf_utils.c  prf_init() 函数添加
    
17. test_init();
    
18. 
    
19. app_task.c   const struct ke_msg_handler app_default_state[] =  里面添加
    
20.     {TEST_DISABLE_IND,                     (ke_msg_func_t) app_test_disable_ind_handler},
    
21.     {TEST_CREATE_DB_CFM,                   (ke_msg_func_t) app_test_create_db_cfm_handler},
    
22. 
    
23. 
    
24. 我现在是不知道问题出在那里？

复制代码