从中央DWS消息来控制物联网MSK DA14585

你好，PM_dialog，

请让我解释一下目前的情况。

1.我按原样使用MSK，我有MSK工具包，其中包含原始FW（外围角色）

2.我正在基于DA14585为我的设备开发一个定制的中央FW（中心角色，能够扫描并连接到外围设备，用户对连接回调工作）

3.我正在努力使用一个发现功能来查找具有特定UUID的外围服务和特征

我在这里浏览了很多主题（包括RW-BLE-GATT-IS文档大约三次），但是多次提到的DSPS项目让我有些困惑。struct spsc_env_tag数据结构对我来说是一个奇迹，因为它是DSPS项目特有的东西。

如果我错了，请纠正我:

1.我需要用我知道的UUID获取特征的句柄（这里是wrbl_dws_control_char，来自MSK FW）

2.然后发出一个只有单个数据字节0x17的消息来启动LED闪烁或0x18来停止LED闪烁

我现在有：

连接上的无效用户（uint8连接idx，结构gapc连接ind const*参数）{arch\u printf（“\r\n设备连接”）；应用程序prf启用（参数->控制HDL）；结构dws_env_tag*dws_env=PRF_env_GET（dws，dws）；prf_disc_svc_send_128（&dws_env->prf_env，connection_idx，（const uint8_t*）dws_CONTROL_UUID）；）静态int-gattc_-disc_-svc_-ind_处理程序（ke_-msg_-id_-const msgid，struct-gattc_-disc_-svc_-ind-const*param，ke_-task_-id_-const dest_-id，ke_-task_-id_-const src_-id）{//获取环境结构dws_-env-tag*dws_-env=PRF_-Get（dws，dws）//即使我们得到多个响应，我们也只存储1个范围的dws_env->shdl=param->start_hdl；dws_env->ehdl=param->end_hdl；dws_env->nb_svc++；返回（已消耗的消息）；}静态int-gattc_-disc_-char_-ind_处理程序（keu-msg_-id_-const msgid，struct-gattc_-disc_-char_-ind-const*param，keu-task_-id_-const dest_-id，keu-task_-id_-const src_-id）{//获取环境结构dws_-env-tag*dws_-env=PRF-env-Get（dws，dws）//prf_search_chars_128（dws_env->ehdl，1，&spsc_env->sps.chars[0]，&spsc_sps_char[0]，param，&spsc_env->last_char_code）；返回（已消耗的消息）；}

我在上面的两个处理程序中都设置了断点，但代码并没有执行。这是为什么呢?

切赫

好吧，我尽量简短明了:

1.函数user_spsc_enable()是一个SPS_CLIENT角色的处理器:

#if (BLE_SPS_CLIENT) {TASK_ID_SPS_CLIENT, user_spsc_create_db, user_spsc_enable}， #endif . log . log . log . log . log . log . log

2.以下是用户_spsc_enable（）正文：

void user_spsc_enable(uint8_t conidx) {struct sps_client_enable_req * req = KE_MSG_ALLOC(sps_client_enable_req, prf_get_task_from_id(TASK_ID_SPS_CLIENT)， TASK_APP, sps_client_enable_req);//填写参数结构req->conidx = conidx;申请- > con_type = PRF_CON_DISCOVERY;//发送消息arch_printf("SPSC ENABLE \r\n");ke_msg_send(要求的);}

在不使用SPS_CLIENT角色的情况下，启动和完成发现过程的步骤是什么?请给我列个单子。

你好，PM_dialog，

请让我解释一下目前的情况:

事实：

1.我按原样使用MSK，我有MSK工具包，其中包含原始FW（外围角色）

2.我正在为基于DA14585的另一台设备开发一个定制的中央FW（中心角色，能够扫描并连接到外围设备，用户对连接回调工作）

3.我正在努力使用一个发现功能来查找具有特定UUID的外围服务和特征

我的问题:

1.函数user_spsc_enable()是一个SPS_CLIENT角色的处理器:

#if (BLE_SPS_CLIENT) {TASK_ID_SPS_CLIENT, user_spsc_create_db, user_spsc_enable}， #endif . log . log . log . log . log . log . log

2.以下是用户_spsc_enable（）正文：

void user_spsc_enable(uint8_t conidx) {struct sps_client_enable_req * req = KE_MSG_ALLOC(sps_client_enable_req, prf_get_task_from_id(TASK_ID_SPS_CLIENT)， TASK_APP, sps_client_enable_req);//填写参数结构req->conidx = conidx;申请- > con_type = PRF_CON_DISCOVERY;//发送消息arch_printf("SPSC ENABLE \r\n");ke_msg_send(要求的);}

在不使用SPS_CLIENT角色的情况下，启动和完成发现过程的步骤是什么?请给我列个单子。

亲爱的总理对话，

我是向前发展的一个最近位和我想问一下你的描述如下状况的审查。我的目标是发现与UUID DWS_CONTROL_UUID的DWS周边服务（{0×09，0X24，0x40的，0x3F的，为0x18，0×26，0x97，0XB0，为0xBB，×44，×44，0x7d，0x70，0x89上，0xa7，0x2E之间}）在MSK定义。

1.添加了一个新的prf_func回调函数。TASK_ID_DWS_CLIENT是枚举KE_API_ID中的一个新项:

常量结构prf_func_callbacks prf_funcs [] = {。。。的#if（BLE_DWS_CLIENT）{TASK_ID_DWS_CLIENT，user_dws_client_create_db，user_dws_client_enable}，#ENDIF。。。}

2.User_dws_client_create_db()基本上是一个消息触发函数，其内容如下:

req->operation=GAPM\U PROFILE\U TASK\U ADD；req->sec\U lvl=get\U user\U prf\U srv\U perm（任务ID\U DWS\U客户端）；req->prf\U任务\U id=任务\U id\U DWS\U客户端；请求->应用程序任务=任务程序；请求->启动\u hdl=0；

3.user_dws_client_enable()是DSPS项目user_spsc_enable()函数的派生函数。该函数应该触发DWS_CLIENT_ENABLE_REQ消息:

void user_dws_client_enable（uint8_t conidx）{struct dws_enable_req*req=KE_MSG_ALLOC（dws_client_enable_req，prf_get_task_from_id（task_id_dws_client），task_APP，dws_enable_req）//填写参数结构req->conidx=conidx；req->con_类型=PRF_con_发现；//发送消息arch_printf（“\r\nDWS客户端已启用”）；ke_msg_send（req）；}

4.DWS_CLIENT_ENABLE_REQ处理程序定义在:

（ke（ke（ke（msg）函数函数函数式（t）dws（dws（KeU msg）函数函数式（t）dws（dws客户）客户（U客户）函数式（t）dws（客户）客户（U客户）函数式（t）dws（U客户）处理者处理者（U）处理者（U）处理者（U）处理者（U）处理者）处理者dws（M）处理者）处理者dws（处理者dws）处理者dws（处理者dws）处理者dws（处理者dws（处理者dws）处理者dws（处理者dws）处理者dws（处理者dws（处理者dws）处理者dws（客户）客户）客户）客户）客户）客户（客户）客户）客户（客户）客户）客户（客户）客户）客户）客户）客户（客户）客户）客户）客户（客户）客户）客户）客户）客户）客户）客户（客户）客户）客户）客户）客户）啊,，（ke_msg_func_t）dws_client_data_tx_req_handler}；

5.dws_client_enable_req_handler发出带有GATTC_DISC_BY_UUID_SVC参数的GATTC_DISC_CMD，此命令应该发现与DWS_CONTROL_UUID的所需UUID对应的服务

静态整数dws_客户端_启用_请求_处理程序（keu msg_id_t const msgid，struct dws_enable_req const*param，keu task_id_t const dest_id，keu task_id_t const src_id）{//dws客户端角色任务环境struct dws_client_env标签*dws_env=PRF env_GET（dws_客户端，dws_客户端）；如果（param->con_type==PRF_con_DISCOVERY）{//开始在对等uint8_t DWS_control_service_uuid[]=DWS_control_uuid上发现DWS；dws_env->last_uuid_req=ATT_DECL_PRIMARY_服务；memcpy（数据仓库环境->最后一个svc请求，数据仓库控制服务ID，附件ID 128）；易失性uint8\u t conidx=KE\u IDX\u GET（dest\u id）；prf_disc_svc_send_128（&dws_env->prf_env，conidx，dws_env->last_svc_req）；//将state设置为discovering ke_state_Set（dest_id，DWS_CLIENT_discovering）；}arch_printf（“\r\nDWS服务发现”）；返回（已消耗的消息）；}

6.这里的问题是，代码命中状态为==ATT\u ERR\u属性为未找到且开始句柄为==0的dws\u客户端\u cmp\u evt\u处理程序：

if(state == dws_client_discovery) {arch_printf("\r\nDWS发现处理器");if ((param->status == ATT_ERR_ATTRIBUTE_NOT_FOUND) || (param->status == ATT_ERR_NO_ERROR)){//当前发现sps_server Service uint8_t dws_service_uuid[] = DWS_CONTROL_UUID;如果(!memcmp(dws_client_env->last_svc_req, dws_service_uuid, ATT_UUID_128_LEN)) {if (dws_client_env->last_uuid_req == ATT_DECL_PRIMARY_SERVICE) {if (dws_client_env-> cs.svc. len)}shdl = = ATT_INVALID_HANDLE ) <<<<<<<< 在这里  <<<<<<<< { // 停止发现过程。dws_client_enable_cfm_send (dws_client_env conidx PRF_ERR_STOP_DISC_CHAR_MISSING);}

我很确定发现参数中的UUID是正确的。

这种行为的原因可能是什么？

请描述在user_dws_config.h中定义的MSK特征与我从DSPS中获取的中心代码中的数据结构之间的关系:

///用于检索DWS客户端特征信息的状态机const struct prf_char_def_128 DWS_client_char[DWS_client_char_MAX]={[DWS_client_CONTROL_char]={DWS_CONTROL_UUID，ATT_mandable，ATT_char PROP|RD | ATT char PROP NTF | ATT spu char PROP|NTF | ATT spsu char PROP WR NO ; RESP}//原始自SPSC://[C(SRV(spsu TX char TX)，附件必须、附件必须、附件必须、附件必须、附件必须、附件必须、附件必须、附件必须、附件必须、附件必须、附件必须用于检索DWS客户机服务特征描述信息的状态机const struct prf_char_desc u def DWS_Client_char_desc u desc[DWS_Client_desc u MAX]={///DWS Client Config[DWS_Client_CONTROL_CLI_CFG]={ATT ATT desc u Client_char CFG，ATT u mandable，DWS_Client_CONTROL char char char}，//原始SPS客户端配置：//[SPSC_SRV_TX_DATA_CLI_CFG]={ATT_DESC u Client_CHAR_CFG，ATT_MANDATORY，SPSC_SRV_TX_DATA_CHAR}，//[SPSC_FLOW_CTRL_CLI CFG]={ATT ATT DESC u Client_CHAR u，ATT_MANDATORY，SPSC_SRV_TX u DATA_CHAR}，}；///DWS客户机服务特征枚举{DWS_客户机_控制_字符=0，DWS_客户机_字符_最大值}；///DWS客户机服务特征描述符枚举{///DWS客户机配置DWS_客户机控制_CLI_CFG，DWS_客户机_DESC_MAX，}；

好了，我设置到了我想要的点:

1.从带有DA14585 FW的自定义PCB连接到带有库存FW IoT-585的MSK设备

2.发现MSK设备服务和特性

3.发送CMD=0x17启动MSK LED闪烁，发送CMD=0x18停止MSK LED闪烁

以下是上述项目的步骤和要点:

A.扫描

Void user_scan_start(Void) {scan_start();Scan_timer = app_easy_timer(1000, user_scan_stop);}

scan_start()函数:

void scan_start(void){struct gapm_start_scan_cmd* cmd = KE_MSG_ALLOC(gapm_start_scan_cmd, TASK_GAPM, TASK_APP, gapm_start_scan_cmd);user_clear_devices ();cmd - > op。代码= GAPM_SCAN_ACTIVE;cmd - > op。addr_src = GAPM_STATIC_ADDR;cmd - >间隔= 15;/ / 600;cmd窗口- > = 5;/ / 400; cmd->mode = GAP_GEN_DISCOVERY; cmd->filt_policy = SCAN_ALLOW_ADV_ALL; cmd->filter_duplic = SCAN_FILT_DUPLIC_EN; ke_msg_send(cmd); is_scanning = true; ke_state_set(TASK_APP, APP_CONNECTABLE); }

用户\u扫描\u停止（）应用程序\u轻松\u计时器处理程序：

void user_scan_stop（void）{app_easy_gap_advertive_stop（）//停止扫描是_scanning=false；对于（int i=0；i<设备计数；i++{用户打印设备（扫描设备[i]）}arch_printf（“\r\n扫描完成！”）；scan_timer=app_easy_timer（50，用户选择设备）；}

b连接

user_choose_device app_easy_timer投手：

void user_choose_device（void）{wdg_freeze（）；arch_printf（“\r\n尝试连接到IoT-585…”）；//在查找到的设备uint8\t i列表中查找IoT-585设备；uint8_t found=0；对于（i=0；i<设备计数；i++）{if（（已扫描设备[i]。设备名称[0]='i'）&&（已扫描设备[i]。设备名称[1]='o'））{found=1；中断；}}如果（找到）{user_connect_to_device（扫描的_devices[i]）}swclock_init（）；}

用户连接到设备功能：

Void user_connect_to_device(struct adv_device device){wdg_resume();arch_printf (" \ r \ nConnecting ");user_print_device_name(设备);arch_printf_flush ();app_easy_gap_start_connection_to_set(设备。adv_addr_type， (uint8_t *)&(device.adv_addr)， MS_TO_DOUBLESLOTS(30));app_easy_gap_start_connection_to ();}

用户\u在\u连接回调上：

空隙user_on_connection（uint8_t connection_idx，结构gapc_connection_req_ind常量* PARAM）{arch_printf（ “\ r \ n设备连接”）;app_prf_enable（param-> conhdl）;//调用prf_func，custs_prf_func和user_prf_func注册的所有功能}

应用程序c中定义的prf_func_回调：

常量结构prf_func_callbacks prf_funcs [] = {{TASK_ID_DWS_CLIENT，user_dws_client_create_db，user_dws_client_enable}，{TASK_ID_INVALID，NULL，NULL}，//不移动。必须始终是最后一个};

用户\u dws\u客户端\u创建\u数据库功能：

void user_dws_client_create_db(void) {struct gapm_profile_task_add_cmd *req = KE_MSG_ALLOC_DYN(gapm_profile_task_add_cmd, TASK_GAPM, TASK_APP, gapm_profile_task_add_cmd, sizeof(struct dws_db_cfg));//填充消息req->操作= GAPM_PROFILE_TASK_ADD;申请- > sec_lvl = get_user_prf_srv_perm (TASK_ID_DWS_CLIENT);申请- > prf_task_id = TASK_ID_DWS_CLIENT;申请- > app_task = TASK_APP;申请- > start_hdl = 0;struct dws_db_cfg *db_cfg = (struct dws_db_cfg *) req->param;db_cfg - >特性= 0;//发送消息ke_msg_send(req);}

user_dws_client_enable功能:

void user_dws_client_enable（uint8_t conidx）{struct dws_enable_req*req=KE_MSG_ALLOC（dws_client_enable_req，prf_get_task_from_id（task_id_dws_client），task_APP，dws_enable_req）//填写参数结构req->conidx=conidx；req->con_类型=PRF_con_发现；//发送消息arch_printf（“\r\nDWS客户端已启用”）；ke_msg_send（req）；}

default_state_handlers:

const struct ke_msg_handler dws_client_default_state [] = {{GATTC_EVENT_IND, (ke_msg_func_t) dws_client_event_ind_handler}, {GATTC_DISC_CHAR_IND, (ke_msg_func_t) dws_client_disc_char_ind_handler}, {GATTC_DISC_SVC_IND, (ke_msg_func_t) dws_client_disc_svc_ind_handler}, / / {GATTC_DISC_CHAR_DESC_IND,一旦发现服务(ke_msg_func_t)dws_client_disc_char_desc_ind_handler}， {DWS_CLIENT_ENABLE_REQ， (ke_msg_func_t)dws_client_enable_req_handler}， {GATTC_CMP_EVT， (ke_msg_func_t)dws_client_cmp_evt_handler}， //一旦命令结束{DWS_CLIENT_DATA_TX_REQ， (ke_msg_func_t)dws_client_data_tx_req_handler}};

dws_client_enable_req_handler:

static int dws_client_enable_req_handler(ke_msg_id_t const msgid, struct dws_enable_req const *param, ke_task_id_t const dest_id, ke_task_id_t const src_id) {// DWS客户端角色任务环境struct dws_client_env_tag *dws_env = PRF_ENV_GET(DWS_CLIENT, DWS_CLIENT);if (param->con_type == PRF_CON_DISCOVERY){//开始发现DWS on peer uint8_t dws_control_service_uuid[] = DWS_SVC_UUID;/ / DWS_CONTROL_UUID;dws_env->last_uuid_req = ATT_DECL_PRIMARY_SERVICE;// ATT_DECL_CHARACTERISTIC;memcpy (dws_env - > last_svc_req、dws_control_service_uuid ATT_UUID_128_LEN);volatile uint8_t conidx = KE_IDX_GET(dest_id);prf_disc_svc_send_128 (&dws_env - > prf_env、conidx dws_env - > last_svc_req);//设置状态为discovery;} arch_printf("\r\nDWS服务发现");返回(KE_MSG_CONSUMED); }

dws\u客户端\u cmp\u evt\u处理程序：

静态INT dws_client_cmp_evt_handler（ke_msg_id_t常量MSGID，结构gattc_cmp_evt常量* PARAM，ke_task_id_t const的DEST_ID，ke_task_id_t常量src_id）{uint8_t状态= ke_state_get（DEST_ID）;uint8_t conidx = KE_IDX_GET(dest_id);//获取环境结构dws_client_env_tag * dws_client_env = PRF_ENV_GET（DWS_CLIENT，dws_client）的地址;UINT8_T状态;if(state == dws_client_discovery) {arch_printf("\r\nDWS发现处理器");如果（（param->状态== ATT_ERR_ATTRIBUTE_NOT_FOUND）||（param->状态== ATT_ERR_NO_ERROR））{//目前发现sps_server服务uint8_t dws_service_uuid [] = DWS_SVC_UUID; // DWS_SVC_UUID;/ / DWS_CONTROL_UUID;如果（！memcmp（dws_client_env-> last_svc_req，dws_service_uuid，ATT_UUID_128_LEN））{如果（dws_client_env-> last_uuid_req == ATT_DECL_PRIMARY_SERVICE）{如果（dws_client_env-> dcs.svc.shdl == ATT_INVALID_HANDLE）{//停止发现过程。dws_client_enable_cfm_send (dws_client_env conidx PRF_ERR_STOP_DISC_CHAR_MISSING);} //太多的服务，只找到一个这样的服务应该如果（dws_client_env-> nb_svc> 1）{//停止发现过程再存在下去。 dws_client_enable_cfm_send(dws_client_env, conidx, PRF_ERR_MULTIPLE_SVC); } else { // Discover DWS Client Device characteristics prf_disc_char_all_send(&(dws_client_env->prf_env), conidx, &(dws_client_env->dcs.svc)); // Keep last UUID requested and for which service in env dws_client_env->last_uuid_req = ATT_DECL_CHARACTERISTIC; } } else if (dws_client_env->last_uuid_req == ATT_DECL_CHARACTERISTIC) { status = prf_check_svc_char_validity_128(DWS_CLIENT_CHAR_MAX, dws_client_env->dcs.chars, dws_client_char); // Check for characteristic properties. if (status == ATT_ERR_NO_ERROR) { dws_client_env->last_uuid_req = ATT_INVALID_HANDLE; dws_client_env->last_char_code = dws_client_char_desc[ATT_DESC_CLIENT_CHAR_CFG].char_code; //Discover characteristic descriptor prf_disc_char_desc_send(&(dws_client_env->prf_env), conidx, &(dws_client_env->dcs.chars[dws_client_env->last_char_code])); } else { // Stop discovery procedure. dws_client_enable_cfm_send(dws_client_env, conidx, status); } } else //Descriptors { //Get code of next char. having descriptors dws_client_env->last_char_code = dws_get_next_desc_char_code(dws_client_env, &dws_client_char_desc[0]); if (dws_client_env->last_char_code != DWS_CLIENT_CHAR_MAX) { prf_disc_char_desc_send(&(dws_client_env->prf_env), conidx, &(dws_client_env->dcs.chars[dws_client_env->last_char_code])); } else { status = prf_check_svc_char_desc_validity(DWS_CLIENT_DESC_MAX, dws_client_env->dcs.descs, dws_client_char_desc, dws_client_env->dcs.chars); dws_client_env->nb_svc = 0; dws_client_enable_cfm_send(dws_client_env, conidx, status); } } } } else { dws_client_enable_cfm_send(dws_client_env, conidx, param->status); } } else if (state == DWS_CLIENT_CONNECTED) { if(param->operation == GATTC_WRITE_NO_RESPONSE) { arch_printf("\r\nDWS no response"); } } return (KE_MSG_CONSUMED); }

dws_client_event_ind_handler:

静态int-dws_-client_-event_-ind_handler（ke_-msg_-id_-const-msgid，struct-gattc_-event_-ind-const*param，ke_-task_-id_-const-dest_-id，ke_-task_-id_-const-src_-id）{struct-dws_-client_-env标签*dws_-env=PRF_-env-GET（dws_-client，dws_-client）//如果（dws_env->dcs.chars[dws_CLIENT_CONTROL_CHAR].val_hdl==param->handle）{}或者如果（dws_env->dcs.chars[dws_CLIENT_CONTROL_REPLY_CHAR].val_hdl==param->handle）{}返回（KE_MSG_consumered）}

dws\u客户端\u磁盘\u字符\u索引\u处理程序：

静态int-dws_-client_-disc_-char_-ind_处理程序（ke_-msg_-id_-const-msgid，struct-gattc_-disc_-char_-ind-const*param，ke_-task_-id_-const-dest_-id，ke_-task_-id_-const-src_-id）{//获取环境结构dws_-client_-env-tag*dws_-env=PRF_-env-Get的地址（dws_-client，dws_-client）；prf_search_chars_128（dws_env->dcs.svc.ehdl，dws_CLIENT_CHAR_MAX，&dws_env->dcs.chars[0]，&dws_CLIENT_CHAR[0]，参数，&dws_env->last_CHAR code）；返回（已消耗的消息）；}

dws_client_disc_svc_ind_handler：

静态INT dws_client_disc_svc_ind_handler（ke_msg_id_t常量MSGID，结构gattc_disc_svc_ind常量* PARAM，ke_task_id_t const的DEST_ID，ke_task_id_t常量src_id）{//获取环境结构dws_client_env_tag的地址* dws_env = PRF_ENV_GET（DWS_CLIENT，dws_client）;//即使我们得到多个响应我们只存储1范围dws_env-> dcs.svc.shdl = param-> start_hdl;dws_env-> dcs.svc.ehdl = param-> end_hdl;dws_env-> nb_svc ++;返回(KE_MSG_CONSUMED);}

dws\u客户端\u磁盘\u字符\u描述\u索引处理程序：

静态int-dws_-client_-disc_-char_-desc_-ind_handler（ke_-msg_-id_-const-msgid，struct-gattc_-disc_-desc_-ind-const*param，ke_-task_-id_-const-dest_-id，ke_-id_-const-src_-id）{//获取环境结构dws_-client_-env-tag*的地址检索SPS描述符prf_search_descs（DWS_CLIENT_DESC u MAX，&DWS_env->dcs.descs[0]，&DWS_CLIENT_char DESC[0]，param，DWS_env->last_char_code）；返回（已消耗的消息）；}

dws_客户端_数据_发送_请求_处理程序：

static int dws_client_data_tx_req_handler(ke_msg_id_t const msgid, struct dws_client_data_tx_req const *param, ke_task_id_t const dest_id, ke_task_id_t const src_id) {struct dws_client_env_tag *dws_client_env = PRF_ENV_GET(DWS_CLIENT, DWS_CLIENT);uint8_t conidx = KE_IDX_GET(dest_id);如果(ke_state_get (KE_BUILD_ID (dws_client_env - > prf_env。prf_task, conidx)) == DWS_CLIENT_CONNECTED) {{prf_gatt_write(&dws_client_env->prf_env, conidx, dws_client_env->dc .chars[DWS_CLIENT_CONTROL_CHAR]. dws_client .chars[DWS_CLIENT_CONTROL_CHAR]. dws_client .chars[DWS_CLIENT_CONTROL_CHAR]. dws_client_env->val_hdl， (uint8_t *)param->data, sizeof(uint8_t) * param->data_length, GATTC_WRITE);返回(KE_MSG_NO_FREE);}} return (KE_MSG_CONSUMED);}

BLE数据发送程序：

静态uint8_t数据=0x17；如果（central_is_connected（）==DWS_CLIENT_connected）{user_send_ble_data（（uint8_t*）&data，1）；arch\u printf（“\r\nCMD发送了%d”，数据）；数据=（数据==0x17）？0x18:0x17；}

user_send_ble_data功能:

void user_send_ble_data（const uint8_t*data，uint16_t length）{struct dws_client_data_tx_req*req=KE_MSG_ALLOC_DYN（dws_client_data_tx_req，prf_get_task_from_id（task_id_dws_client_客户端），task_APP，dws_client_data_tx_req，length）；请求->数据长度=长度；memcpy（&req->data[0]，data，length）；ke_msg_send（req）；}

C特点：

常量结构prf_char_def_128 dws_client_char [DWS_CLIENT_CHAR_MAX] = {[DWS_CLIENT_ACCEL_CHAR] = {DWS_ACCEL_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，[DWS_CLIENT_GYRO_CHAR] = {DWS_GYRO_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，[DWS_CLIENT_MAG_CHAR] = {DWS_MAG_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，[DWS_CLIENT_BARO_CHAR] = {DWS_BARO_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，[DWS_CLIENT_HUM_CHAR] = {DWS_HUM_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，[DWS_CLIENT_TEMP_CHAR] = {DWS_TEMP_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，[DWS_CLIENT_SENSF_CHAR] = {DWS_SENSF_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，[DWS_CLIENT_FEAT_CHAR] = {DWS_FEAT_UUID，ATT_MANDATORY，ATT_CHAR_PROP_RD}，[DWS_CLIENT_CONTROL_CHAR] = {DWS_CONTROL_UUID，ATT_MANDATORY，ATT_CHAR_PROP_WR}，[DWS_CLIENT_CONTROL_REPLY_CHAR] = {DWS_CONTROL_REPLY_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，[DWS_CLIENT_MULTI_SENS_CHAR] = {DWS_MULTI_SENS_UUID，ATT_MANDATORY，ATT_CHAR_PROP_NTF}，};常量结构prf_char_desc_def dws_client_char_desc [DWS_CLIENT_DESC_MAX] = {/// DWS客户端配置[DWS_CLIENT_ACCEL_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_ACCEL_CHAR}，[DWS_CLIENT_GYRO_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_GYRO_CHAR}，[DWS_CLIENT_MAG_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_MAG_CHAR}[DWS_CLIENT_BARO_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_BARO_CHAR}，[DWS_CLIENT_HUM_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_HUM_CHAR}，[DWS_CLIENT_TEMP_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_TEMP_CHAR}，[DWS_CLIENT_SENSF_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_SENSF_CHAR}，[DWS_CLIENT_CONTROL_REPLY_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_CONTROL_REPLY_CHAR}，[DWS_CLIENT_MULTI_SENS_NTF_CFG] = {ATT_DESC_CLIENT_CHAR_CFG，ATT_MANDATORY，DWS_CLIENT_MULTI_SENS_CHAR}，};

d .的数据结构:

struct dws_client_data_tx_req{///连接索引uint16_t conidx;//需要写入的属性句柄uint16_t句柄;///要写入的数据长度uint16_t data_length;//将数据写入属性数据库uint8_t Data [1];//[__ARRAY_EMPTY];};

结构dws_client_env_tag {///轮廓环境prf_env_t prf_env;///服务启动手柄uint16_t SHDL;///要存储uint8_t max_nb_att属性的DB最大数量;///正在进行的操作结构ke_msg *操作;///光标上连接用于uint8_t光标通知对等设备;/// CCC手柄索引，通知/指示忙状态uint8_t ccc_idx期间使用;///通过应用结构co_list值设定值的列表;/// CUSTS1任务状态ke_state_t状态[DWS_IDX_MAX];///档案连接信息///最后要求UUID（跟踪两个服务和焦炭）uint16_t last_uuid_req;///最后的服务，为某事被发现uint8_t last_svc_req [ATT_UUID_128_LEN] /// Last char. code requested to read. uint8_t last_char_code; /// counter used to check service uniqueness uint8_t nb_svc; /// DWS Client Service Device Service information recovered from discovery struct dws_client_content dcs; }; struct spsc_db_cfg { ///Database configuration uint16_t features; };

结构adv_设备{uint8_t索引///多种广告设备的索引uint8_t evt_类型///事件类型：uint8\u t adv\u addr\u类型///广告地址类型：public/random struct bd_addr adv_addr///广告地址值uint8\u t设备名称\u len///广告包uint8设备名称中的数据长度[ADV_Data_LEN]///广告包uint8设备规格的数据；uint8设备规格[ADV_DATA_LEN]；uint8_t flags_len；uint8_t标志[ADV_DATA_LEN]；uint8_t服务[4]；uint8_t uuid_len；uint8_t uuid[高级数据长度]；uint8_t uuid_sol_len；uint8_t uuid_sol[ADV_DATA_LEN]；uint8原材料；uint8_t raw[ADV_DATA_LEN]；int8_t rssi///广告包的RSSI值}；结构扫描\配置{///操作代码。uint8_t代码；///设备uint8\u t addr\u src；的自有BD地址源扫描间隔uint16\u t间隔；//扫描窗口大小uint16\u t window；//扫描模式uint8\u t模式；///扫描筛选器策略uint8\u t筛选器策略；//扫描重复筛选策略uint8\u t filter\u duplic；}；

枚举{///空闲状态DWS\U CLIENT\U IDLE，///连接状态DWS\U CLIENT\U Connected，///发现DWS\U CLIENT\U发现，///定义的状态数。DWS_客户端_状态_最大值}；///DWS客户端服务特征枚举{/////DWS\U客户端加速字符=0、DWS\U客户端陀螺字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U客户端字符、DWS\U控制字符、DWS\U客户端字符、应答字符、DWS\U客户端字符DWS客户端（客户端）陀螺客户端（客户端）陀螺陀螺陀螺陀螺（陀螺）文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件（客户端）客户端（客户端）陀螺陀螺陀螺文件文件文件（CFG）CFG，DWS客户端（客户端）文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件（客户端）服务服务服务（客户端）文件文件文件文件（文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件文件（文件文件文件文件）服务服务服务（文件文件）服务（文件文件）服务（文件）服务）服务（文件）服务）服务（文件文件）服务（文件文件文件）服务（文件）服务（文件）服务）服务）服务（文件文件）服务）服务（文件）服务（文件）服务（文件）服务（文件）服务）服务）服务（文件）服务）服务）服务（文件文件）服务）服务（文件（文件）服务）服务）服务）服务）(一)///DWS客户端主机API消息枚举{///DWS客户端角色从应用程序启用请求。DWS\u客户端\u ENABLE\u REQ=KE\u FIRST\u MSG（任务ID\u DWS\u客户端），///SPS主机角色启用对应用程序的确认。DWS\u CLIENT\u ENABLE\u CFM，///请求传输数据DWS\u CLIENT\u data\u TX\u REQ，///确认数据已发送DWS\u CLIENT\u data\u TX\u CFM，///将数据发送到应用程序DWS\u CLIENT\u data\u RX\u IND，//发送流控制状态DWS\u CLIENT\u RX\u flow\u CTRL\u REQ，///指示流控制状态DWS\u CLIENT\u TX flow\u flow\u CTRL\u IND服务信息结构dws\U客户端\U内容{///服务信息结构prf\U svc svc；///特征信息：结构prf_char_inf chars[DWS_CLIENT_char_MAX]；//特征cfg结构prf_char_desc_inf descs[DWS_CLIENT_desc_MAX]；}；

我相信它将帮助另一个为DA14585实现一个非常简单的中央设备FW而奋斗的人。

如果您想让我联系，请通过LinkedIn与我联系https://www.linkedin.com/in/petr-dvorak-hw/

你好PM_Dialog,

我最近的帖子并不是想要对585-MSK项目提出任何建议。我使用585-MSK作为外围设备，我说过很多次了。我一直在开发一个自定义板和我的自定义板，我一直在开发一个自定义FW。

任何中央角色的固件示例在这里都非常罕见。唯一提到的项目是DSPS项目，一次又一次。但是将中心角色实现到定制项目中并不是那么简单。我试图帮助这里的社区。在我达到目标之前，我已经花了大约两周的时间学习文档和DSP项目。

切赫