#include <rtthread.h>
#include <finsh.h>
#include "common.h"
#include "param_config.h"
#include "ble_pub.h"
#include "drv_oled.h"
#include "flash.h"


#include "belon_ble.h"
#include "app_temperature.h"

#if (CFG_BLE_VERSION == BLE_VERSION_5_2)
#include "app_ble.h"
#include "app_sdp.h"
#include "app_ble_init.h"
#if (BLE_APP_SEC)
#include "app_sec.h"
#endif
#include "kernel_mem.h"
#define BUILD_UINT16(loByte, hiByte) \
          ((uint16_t)(((loByte) & 0x00FF) + (((hiByte) & 0x00FF) << 8)))

#define BK_ATT_DECL_PRIMARY_SERVICE_128     {0x00,0x28,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
#define BK_ATT_DECL_CHARACTERISTIC_128      {0x03,0x28,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
#define BK_ATT_DESC_CLIENT_CHAR_CFG_128     {0x02,0x29,0,0,0,0,0,0,0,0,0,0,0,0,0,0}

#define WRITE_REQ_CHARACTERISTIC_128        {0x01,0xFF,0,0,0x34,0x56,0,0,0,0,0x28,0x37,0,0,0,0}
#define INDICATE_CHARACTERISTIC_128         {0x02,0xFF,0,0,0x34,0x56,0,0,0,0,0x28,0x37,0,0,0,0}
#define NOTIFY_CHARACTERISTIC_128           {0x03,0xFF,0,0,0x34,0x56,0,0,0,0,0x28,0x37,0,0,0,0}

static const uint8_t test_svc_uuid[16] = {0xFF,0xFF,0,0,0x34,0x56,0,0,0,0,0x28,0x37,0,0,0,0};
app_dev_config_t dev_config = {0};

enum
{
	TEST_IDX_SVC,
	TEST_IDX_FF01_VAL_CHAR,
	TEST_IDX_FF01_VAL_VALUE,
	TEST_IDX_FF02_VAL_CHAR,
	TEST_IDX_FF02_VAL_VALUE,
	TEST_IDX_FF02_VAL_IND_CFG,
	TEST_IDX_FF03_VAL_CHAR,
	TEST_IDX_FF03_VAL_VALUE,
	TEST_IDX_FF03_VAL_NTF_CFG,
	TEST_IDX_NB,
};
uint8_t actv_idx_adv; 
bk_attm_desc_t test_att_db[TEST_IDX_NB] =
{
	//  Service Declaration
	[TEST_IDX_SVC]              = {BK_ATT_DECL_PRIMARY_SERVICE_128, PROP(RD), 0},

	//  Level Characteristic Declaration
	[TEST_IDX_FF01_VAL_CHAR]    = {BK_ATT_DECL_CHARACTERISTIC_128,  PROP(RD), 0},
	//  Level Characteristic Value
	[TEST_IDX_FF01_VAL_VALUE]   = {WRITE_REQ_CHARACTERISTIC_128,    PROP(WR), 128|OPT(NO_OFFSET)},

	[TEST_IDX_FF02_VAL_CHAR]    = {BK_ATT_DECL_CHARACTERISTIC_128,  PROP(RD), 0},
	//  Level Characteristic Value
	[TEST_IDX_FF02_VAL_VALUE]   = {INDICATE_CHARACTERISTIC_128,     PROP(I), 128|OPT(NO_OFFSET)},

	//  Level Characteristic - Client Characteristic Configuration Descriptor

	[TEST_IDX_FF02_VAL_IND_CFG] = {BK_ATT_DESC_CLIENT_CHAR_CFG_128, PROP(RD)|PROP(WR),OPT(NO_OFFSET)},

	[TEST_IDX_FF03_VAL_CHAR]    = {BK_ATT_DECL_CHARACTERISTIC_128,  PROP(RD), 0},
	//  Level Characteristic Value
	[TEST_IDX_FF03_VAL_VALUE]   = {NOTIFY_CHARACTERISTIC_128,       PROP(N), 128|OPT(NO_OFFSET)},

	//  Level Characteristic - Client Characteristic Configuration Descriptor

	[TEST_IDX_FF03_VAL_NTF_CFG] = {BK_ATT_DESC_CLIENT_CHAR_CFG_128, PROP(RD)|PROP(WR), OPT(NO_OFFSET)},
};
ble_err_t bk_ble_init(void)
{
    ble_err_t status = ERR_SUCCESS;

    struct bk_ble_db_cfg ble_db_cfg;

    ble_db_cfg.att_db = test_att_db;
    ble_db_cfg.att_db_nb = TEST_IDX_NB;
    ble_db_cfg.prf_task_id = 0;
    ble_db_cfg.start_hdl = 0;
    ble_db_cfg.svc_perm = BK_PERM_SET(SVC_UUID_LEN, UUID_16);
    memcpy(&(ble_db_cfg.uuid[0]), &test_svc_uuid[0], 16);

    status = bk_ble_create_db(&ble_db_cfg);

    return status;
}

void cli_ble_write_callback(write_req_t *write_req)
{
    bk_printf("write_cb[prf_id:%d, att_idx:%d, len:%d]\r\n", write_req->prf_id, write_req->att_idx, write_req->len);
    for(int i = 0; i < write_req->len; i++)
    {
        bk_printf("0x%x ", write_req->value[i]);
    }
    bk_printf("\r\n");
}

uint8_t cli_ble_read_callback(read_req_t *read_req)
{
    bk_printf("read_cb[prf_id:%d, att_idx:%d]\r\n", read_req->prf_id, read_req->att_idx);
    read_req->value[0] = 0x10;
    read_req->value[1] = 0x20;
    read_req->value[2] = 0x30;
    return 3;
}

static void ble_command_usage(void)
{
    bk_printf("ble help           - Help information\n");
    bk_printf("ble active         - Active ble to with BK7231BTxxx\n");    
	bk_printf("ble start_adv      - Start advertising as a slave device\n");
	bk_printf("ble stop_adv       - Stop advertising as a slave device\n");
    bk_printf("ble notify prf_id att_id value\n");
    bk_printf("                   - Send ntf value to master\n");
    bk_printf("ble indicate prf_id att_id value\n");
    bk_printf("                   - Send ind value to master\n");

    bk_printf("ble disc           - Disconnect\n");
    bk_printf("ble dut            - dut test\n");
}


void sdp_event_cb(sdp_notice_t notice, void *param)
{
	switch (notice) {
		case SDP_CHARAC_NOTIFY_EVENT:
			{
				sdp_event_t *g_sdp = (sdp_event_t *)param;
				bk_printf("[SDP_CHARAC_NOTIFY_EVENT]con_idx:%d,hdl:0x%x,value_length:%d\r\n",g_sdp->con_idx,g_sdp->hdl,g_sdp->value_length);
			}
			break;
		case SDP_CHARAC_INDICATE_EVENT:
			{
				sdp_event_t *g_sdp = (sdp_event_t *)param;
				bk_printf("[SDP_CHARAC_INDICATE_EVENT]con_idx:%d,hdl:0x%x,value_length:%d\r\n",g_sdp->con_idx,g_sdp->hdl,g_sdp->value_length);
			}
			break;
		case SDP_CHARAC_READ:
			{
				sdp_event_t *g_sdp = (sdp_event_t *)param;
				bk_printf("[SDP_CHARAC_READ]con_idx:%d,hdl:0x%x,value_length:%d\r\n",g_sdp->con_idx,g_sdp->hdl,g_sdp->value_length);
			}
			break;
		case SDP_DISCOVER_SVR_DONE:
			{
				bk_printf("[SDP_DISCOVER_SVR_DONE]\r\n");
			}
			break;
		case SDP_CHARAC_WRITE_DONE:
			{
				bk_printf("[SDP_CHARAC_WRITE_DONE]\r\n");
			}
			break;
		default:
			bk_printf("[%s]Event:%d\r\n",__func__,notice);
			break;
	}
}

void ble_cmd_cb(ble_cmd_t cmd, ble_cmd_param_t *param)
{
	bk_printf("cmd:%d idx:%d status:%d\r\n", cmd, param->cmd_idx, param->status);
}


void ble_notice_cb(ble_notice_t notice, void *param)
{
	switch (notice) {
	case BLE_5_STACK_OK:
		bk_printf("ble stack ok");
		break;
	case BLE_5_WRITE_EVENT:
	{
		write_req_t *w_req = (write_req_t *)param;
		bk_printf("write_cb:conn_idx:%d, prf_id:%d, add_id:%d, len:%d, data[0]:%02x\r\n",
		w_req->conn_idx, w_req->prf_id, w_req->att_idx, w_req->len, w_req->value[0]);

		bk_printf("data:%s\r\n",w_req->value);
		uint8_t data[32]="";
		memcpy(data, w_req->value, w_req->len);
		if(strstr((char *)data,"AT+BIND")!=NULL){
			//flash_read(0x60000,9,complete_name);
			memset((void *)&dev_config, 0, sizeof(dev_config));
			//flash_read((uint8_t *)&dev_config, sizeof(dev_config), (UINT32)0x1FD000);
			//sscanf(w_req->value,"AT+BIND=%s", dev_config.bind_mac);
			bk_printf("mac:%s\r\n",w_req->value);
			//flash_write((uint8_t *)&dev_config, sizeof(dev_config), (UINT32)0x1FD000);
			
		}
		break;
	}
	case BLE_5_READ_EVENT:
	{
		read_req_t *r_req = (read_req_t *)param;
		bk_printf("read_cb:conn_idx:%d, prf_id:%d, add_id:%d\r\n",
			r_req->conn_idx, r_req->prf_id, r_req->att_idx);

		#if (CFG_BLE_VERSION == BLE_VERSION_5_2)
		uint16_t length = 3;
		r_req->value = kernel_malloc(length, KERNEL_MEM_KERNEL_MSG);
		r_req->value[0] = 0x12;
		r_req->value[1] = 0x34;
		r_req->value[2] = 0x56;

		app_gatts_rsp_t rsp;
		rsp.token = r_req->token;
		rsp.con_idx = r_req->conn_idx;
		rsp.attr_handle = r_req->hdl;
		rsp.status = GAP_ERR_NO_ERROR;
		rsp.att_length = length;
		rsp.value_length = length;
		rsp.value = r_req->value;

		app_ble_gatts_set_attr_value(rsp.attr_handle, rsp.value_length, rsp.value);
		bk_ble_gatts_read_response(&rsp);
		kernel_free(r_req->value);
		#else
		r_req->value[0] = 0x12;
		r_req->value[1] = 0x34;
		r_req->value[2] = 0x56;
		r_req->length = 3;
		#endif

		break;
	}
	case BLE_5_REPORT_ADV:
	{
		recv_adv_t *r_ind = (recv_adv_t *)param;
		#if 0 
		//adv]r_ind:actv_idx:0,evt_type:57 adv_addr:e5:e6:b6:09:28:37,rssi:188 data_len27
		bk_printf("[%s]r_ind:actv_idx:%d,evt_type:%d adv_addr:%02x:%02x:%02x:%02x:%02x:%02x,rssi:%d\r\n",
			((r_ind->evt_type&0x7) == 3)?"scan-rsp":((r_ind->evt_type&0x7) == 1)?"adv":"unknow",
			r_ind->actv_idx,r_ind->evt_type, r_ind->adv_addr[0], r_ind->adv_addr[1], r_ind->adv_addr[2],
			r_ind->adv_addr[3], r_ind->adv_addr[4], r_ind->adv_addr[5],r_ind->rssi);

		bk_printf("data_len%d\r\n",r_ind->data_len);
		#endif
		//ble_parser_recv_adv(r_ind);
		temperature_adv_callback(r_ind);
		/*memset((void *)&dev_config, 0, sizeof(dev_config));
		//flash_read(0x1FD000, sizeof(dev_config), (uint8_t *)&dev_config);
		*Device_Mac=*(dev_config.bind_mac);*/

		//uint8_t Device_Mac[6]={0x1c,0x16,0xC6,0x02,0x09,0xd6};
		#if 0
		if(r_ind->adv_addr[0]==Device_Mac[0]&&r_ind->adv_addr[1]==Device_Mac[1]&&r_ind->adv_addr[2]==Device_Mac[2]&&
			r_ind->adv_addr[3]==Device_Mac[3]&&r_ind->adv_addr[4]==Device_Mac[4]&&r_ind->adv_addr[5]==Device_Mac[5])
			{
				bk_printf("[%s]r_ind:actv_idx:%d,evt_type:%d adv_addr:%02x:%02x:%02x:%02x:%02x:%02x,rssi:%d\r\n",
					((r_ind->evt_type&0x7) == 3)?"scan-rsp":((r_ind->evt_type&0x7) == 1)?"adv":"unknow",
					r_ind->actv_idx,r_ind->evt_type, r_ind->adv_addr[0], r_ind->adv_addr[1], r_ind->adv_addr[2],
					r_ind->adv_addr[3], r_ind->adv_addr[4], r_ind->adv_addr[5],r_ind->rssi);
				
					ble_parser_recv_adv(r_ind);
				//int i;
				//for(i=0;i<r_ind->data_len;i++){
				//	bk_printf("0x%02x,",r_ind->data[i]);
				//}
				
				bk_printf("\r\n");
				
				memset(Temphex,0,sizeof(Temphex));
				sprintf((char*)Temphex,"%02x%02x",r_ind->data[23],r_ind->data[24]);
				memset(temphex,0,sizeof(temphex));
				sprintf((char*)temphex,"%02x%02x",r_ind->data[25],r_ind->data[26]);
				memset(bathex,0,sizeof(bathex));
				sprintf((char*)bathex,"%02x",r_ind->data[27]);
				bk_printf("%s\r\n", Temphex);
				bk_printf("%s\r\n", temphex);
				bk_printf("%s\r\n", bathex);
				Temp=strtol((char*)Temphex,&endPtr, 16);
				Temp2=strtol((char*)temphex,&endPtr2, 16);
				bat=strtol((char*)bathex,&endPtr2, 16);
				bk_printf("%d\r\n", Temp);
				bk_printf("%d\r\n", Temp2);
				bk_printf("%d\r\n", bat);


				
				/*
				temph=Temp/100;
				templ=Temp%100/10;
				temp2h=Temp2/100;
				temp2l=Temp2%100/10;*/
			}
		#endif
		break;
	}
	case BLE_5_REPORT_PER_ADV:
	{
		recv_adv_t *r_ind = (recv_adv_t *)param;

		bk_printf("[%s]r_ind:actv_idx:%d,evt_type:%d rssi:%d data_len:%d data[0]:0x%x\r\n","per-adv",
			r_ind->actv_idx,r_ind->evt_type, r_ind->rssi, r_ind->data_len, r_ind->data[0]);
		break;
	}
	case BLE_5_MTU_CHANGE:
	{
		mtu_change_t *m_ind = (mtu_change_t *)param;
		bk_printf("BLE_5_MTU_CHANGE:conn_idx:%d, mtu_size:%d\r\n", m_ind->conn_idx, m_ind->mtu_size);
		break;
	}
	case BLE_5_PHY_IND_EVENT:
	{
		conn_phy_ind_t *set_phy = (conn_phy_ind_t *)param;
		bk_printf("BLE_5_PHY_IND_EVENT:conn_idx:%d, tx_phy:0x%x, rx_phy:0x%x\r\n", set_phy->conn_idx, set_phy->tx_phy, set_phy->rx_phy);
		break;
	}
	case BLE_5_CONNECT_EVENT:
	{
		//bk_ble_adv_stop(actv_idx_adv, ble_cmd_cb);
		//bk_ble_delete_advertising(actv_idx_adv, ble_cmd_cb);
		temperature_led_ble(1);
		conn_ind_t *c_ind = (conn_ind_t *)param;
		bk_printf("c_ind:conn_idx:%d, addr_type:%d, peer_addr:%02x:%02x:%02x:%02x:%02x:%02x\r\n",
			c_ind->conn_idx, c_ind->peer_addr_type, c_ind->peer_addr[0], c_ind->peer_addr[1],
			c_ind->peer_addr[2], c_ind->peer_addr[3], c_ind->peer_addr[4], c_ind->peer_addr[5]);
		break;
	}
	case BLE_5_DISCONNECT_EVENT:
	{
		temperature_led_ble(0);
		discon_ind_t *d_ind = (discon_ind_t *)param;
		bk_printf("d_ind:conn_idx:%d,reason:%d\r\n", d_ind->conn_idx,d_ind->reason);
		//断开连接之后 重新打开广播
	
		//belon_ble_init_adv();
		break;
	}
	case BLE_5_ATT_INFO_REQ:
	{
		att_info_req_t *a_ind = (att_info_req_t *)param;
		bk_printf("a_ind:conn_idx:%d\r\n", a_ind->conn_idx);
		a_ind->length = 128;
		a_ind->status = ERR_SUCCESS;
		break;
	}
	case BLE_5_CREATE_DB:
	{
		create_db_t *cd_ind = (create_db_t *)param;
		bk_printf("cd_ind:prf_id:%d, status:%d\r\n", cd_ind->prf_id, cd_ind->status);
		break;
	}
	#if (BLE_CENTRAL)
	case BLE_5_INIT_CONNECT_EVENT:
	{
		conn_ind_t *c_ind = (conn_ind_t *)param;
		#if (CFG_BLE_VERSION == BLE_VERSION_5_2)
		app_ble_get_peer_feature(c_ind->conn_idx);
		app_ble_set_le_pkt_size(c_ind->conn_idx,LE_MAX_OCTETS);
		app_ble_mtu_exchange(c_ind->conn_idx);
		sdp_discover_all_service(c_ind->conn_idx);
		#endif
		bk_printf("BLE_5_INIT_CONNECT_EVENT:conn_idx:%d, addr_type:%d, peer_addr:%02x:%02x:%02x:%02x:%02x:%02x\r\n",
			c_ind->conn_idx, c_ind->peer_addr_type, c_ind->peer_addr[0], c_ind->peer_addr[1],
			c_ind->peer_addr[2], c_ind->peer_addr[3], c_ind->peer_addr[4], c_ind->peer_addr[5]);
		break;
	}
	case BLE_5_INIT_DISCONNECT_EVENT:
	{
		discon_ind_t *d_ind = (discon_ind_t *)param;
		bk_printf("BLE_5_INIT_DISCONNECT_EVENT:conn_idx:%d,reason:0x%x\r\n", d_ind->conn_idx,d_ind->reason);
		break;
	}
	#endif
	case BLE_5_INIT_CONN_PARAM_UPDATE_REQ_EVENT:
	{
		conn_param_req_t *d_ind = (conn_param_req_t *)param;
		bk_printf("BLE_5_INIT_CONN_PARAM_UPDATE_REQ_EVENT:conn_idx:%d,intv_min:%d,intv_max:%d,time_out:%d\r\n",d_ind->conn_idx,
			d_ind->intv_min,d_ind->intv_max,d_ind->time_out);
	}break;
	case BLE_5_INIT_CONN_PARAM_UPDATE_IND_EVENT:
	{
		conn_update_ind_t *d_ind = (conn_update_ind_t *)param;
		bk_printf("BLE_5_INIT_CONN_PARAM_UPDATE_IND_EVENT:conn_idx:%d,interval:%d,time_out:%d,latency\r\n",d_ind->conn_idx,
			d_ind->interval,d_ind->time_out,d_ind->latency);
	}break;
	case BLE_5_SDP_REGISTER_FAILED:
		bk_printf("BLE_5_SDP_REGISTER_FAILED\r\n");
		break;
	case BLE_5_GAP_CMD_CMP_EVENT:
	{
		ble_cmd_cmp_evt_t *evt = (ble_cmd_cmp_evt_t *)param;
		bk_printf("BLE_5_GAP_CMD_CMP_EVENT cmd:0x%x,conn_idx:%d,status:0x%x\r\n",evt->cmd,evt->conn_idx,evt->status);
		break;
	}
	case BLE_5_TX_DONE:
	{
		atts_tx_t *evt = (atts_tx_t *)param;
		bk_printf("BLE_5_TX_DONE conn_idx:%d,prf_id:%d,att_idx:%d,status:%d\r\n",
		evt->conn_idx,evt->prf_id,evt->att_idx,evt->status);
	}break;
	default:
		break;
	}
}

static void ble(int argc, char **argv)
{
	uint8_t adv_data[31];
	uint8_t actv_idx;
	if ((argc < 2) || (os_strcmp(argv[1], "help") == 0))
    {
        ble_command_usage();
        return ;
    }
	if (os_strcmp(argv[1], "active") == 0) {
		ble_set_notice_cb(ble_notice_cb);
		ble_entry();
		bk_ble_init();
	}
	if (os_strcmp(argv[1], "create_adv") == 0) {
		actv_idx = app_ble_get_idle_actv_idx_handle(ADV_ACTV);
        bk_printf("actv_idx = %d\r\n",actv_idx);
		bk_ble_create_advertising(actv_idx, 7, 160, 160, ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "set_adv_data") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		adv_data[0] = 0x0A;
		adv_data[1] = 0x09;
		#if (CFG_SOC_NAME == SOC_BK7238)
		memcpy(&adv_data[2], "7238_BLE", 9);
		#else
		memcpy(&adv_data[2], "7252n_BLE", 9);
		#endif
		adv_data[11] = 0x03;
		adv_data[12] = 0x19;
		adv_data[13] = app_ble_env.dev_appearance & 0xFF;
		adv_data[14] = (app_ble_env.dev_appearance >> 8) & 0xFF;

		bk_ble_set_adv_data(os_strtoul(argv[2], NULL, 10), adv_data, 0xF, ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "set_rsp_data") == 0) {
		uint8_t adv_data_len;
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		adv_data[0] = 0x06;
		adv_data[1] = 0x08;
		#if (CFG_SOC_NAME == SOC_BK7238)
		memcpy(&adv_data[2], "7238", 5);
		#else
		memcpy(&adv_data[2], "7252n", 5);
		#endif
		#if (BLE_HID_DEVICE)
		adv_data[7] = 0x03;
		adv_data[8] = 0x03;
		adv_data[9] = 0x12;
		adv_data[10] = 0x18;
		adv_data_len = 0xB;
		#else
		adv_data_len = 0x7;
		#endif
		bk_ble_set_scan_rsp_data(os_strtoul(argv[2], NULL, 10), adv_data, adv_data_len, ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "start_adv") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
        bk_ble_start_advertising(os_strtoul(argv[2], NULL, 10), 0, ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "stop_adv") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_stop_advertising(os_strtoul(argv[2], NULL, 10), ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "delete_adv") == 0) {
		if (argc < 3){	
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_delete_advertising(os_strtoul(argv[2], NULL, 10), ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "create_scan") == 0) {
		actv_idx = app_ble_get_idle_actv_idx_handle(SCAN_ACTV);
		bk_ble_create_scaning(actv_idx, ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "start_scan") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_start_scaning(os_strtoul(argv[2], NULL, 10), 100, 30, ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "stop_scan") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_stop_scaning(os_strtoul(argv[2], NULL, 10), ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "delete_scan") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_delete_scaning(os_strtoul(argv[2], NULL, 10), ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "update_conn") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_update_param(os_strtoul(argv[2], NULL, 10), 50, 50, 0, 800);
	}
	if (os_strcmp(argv[1], "dis_conn") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_disconnect(os_strtoul(argv[2], NULL, 10));
	}
	if (os_strcmp(argv[1], "mtu_change") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_gatt_mtu_change(os_strtoul(argv[2], NULL, 10));
	}
	if (os_strcmp(argv[1], "init_adv") == 0) {
		struct adv_param adv_info;
		adv_info.channel_map = 7;
		adv_info.duration = 0;
		adv_info.prop = (1 << ADV_PROP_CONNECTABLE_POS) | (1 << ADV_PROP_SCANNABLE_POS);
		adv_info.interval_min = 160;
		adv_info.interval_max = 160;
		adv_info.advData[0] = 0x09;
		adv_info.advData[1] = 0x09;
		memcpy(&adv_info.advData[2], "7252nBLE", 8);
		adv_info.advDataLen = 10;
		adv_info.respData[0] = 0x06;
		adv_info.respData[1] = 0x08;
		memcpy(&adv_info.respData[2], "7252n", 5);
		adv_info.respDataLen = 7;
		actv_idx = app_ble_get_idle_actv_idx_handle(ADV_ACTV);
		bk_ble_adv_start(actv_idx, &adv_info, ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "deinit_adv") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_adv_stop(os_strtoul(argv[2], NULL, 10), ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "init_scan") == 0) {
		struct scan_param scan_info;
		scan_info.channel_map = 7;
		scan_info.interval = 100;
		scan_info.window = 30;
		actv_idx = app_ble_get_idle_actv_idx_handle(SCAN_ACTV);
		bk_ble_scan_start(actv_idx, &scan_info, ble_cmd_cb);
	}
	if (os_strcmp(argv[1], "deinit_scan") == 0) {
		if (argc < 3){
			bk_printf("\nThe number of param is wrong!\n");
			return;
		}
		bk_ble_scan_stop(os_strtoul(argv[2], NULL, 10), ble_cmd_cb);
	}
	uint8_t conn_idx;
	if (os_strcmp(argv[1], "con_create") == 0)
	{
		ble_set_notice_cb(ble_notice_cb);
		conn_idx = app_ble_get_idle_conn_idx_handle(INIT_ACTV);
		bk_printf("------------->conn_idx:%d\r\n",conn_idx);
		sdp_set_notice_cb(sdp_event_cb);
		bk_ble_create_init(conn_idx, ble_cmd_cb);
	}
	else if ((os_strcmp(argv[1], "con_start") == 0) && (argc >= 5))
	{
		struct bd_addr bdaddr;
		unsigned char addr_type = ADDR_PUBLIC;
		int addr_type_str = atoi(argv[3]);
		int actv_idx_str = atoi(argv[4]);
		bk_printf("idx:%d,addr_type:%d\r\n",actv_idx_str,addr_type_str);
		if((addr_type_str > ADDR_RPA_OR_RAND)||(actv_idx_str >= 0xFF)){
			return;
		}
		conn_idx = actv_idx_str;
		hexstr2bin(argv[2], bdaddr.addr, GAP_BD_ADDR_LEN);
		addr_type = addr_type_str;
		bk_ble_init_set_connect_dev_addr(conn_idx,&bdaddr,addr_type);
		bk_ble_init_start_conn(conn_idx,10000,ble_cmd_cb);
		
	}
	else if ((os_strcmp(argv[1], "con_stop") == 0) && (argc >= 3))
	{
		int actv_idx_str = atoi(argv[2]);
		bk_printf("idx:%d\r\n",actv_idx_str);
		if(actv_idx_str >= 0xFF){
			return;
		}
		conn_idx = actv_idx_str;
		bk_ble_init_stop_conn(conn_idx,ble_cmd_cb);
	}
	else if ((os_strcmp(argv[1], "con_dis") == 0) && (argc >= 3))
	{
		int actv_idx_str = atoi(argv[2]);
		bk_printf("idx:%d\r\n",actv_idx_str);
		if(actv_idx_str >= 0xFF){
			return;
		}
		conn_idx = actv_idx_str;
		app_ble_master_appm_disconnect(conn_idx);
	}
	else if (os_strcmp(argv[1], "con_read") == 0)
	{
		if(argc < 4){
			bk_printf("param error\r\n");
			return;
		}
		int actv_idx_str = atoi(argv[3]);
		bk_printf("idx:%d\r\n",actv_idx_str);
		if(actv_idx_str >= 0xFF){
			return;
		}
		conn_idx = actv_idx_str;
		int handle = atoi(argv[2]);
		if(handle >=0 && handle <= 0xFFFF){
			bk_ble_read_service_data_by_handle_req(conn_idx,handle);
		}
		else{
			bk_printf("handle(%x) error\r\n",handle);
		}
	}else if (os_strcmp(argv[1], "con_write") == 0)
	{
		//cmd:ble con_write 24 0
		if(argc < 4){
			bk_printf("param error\r\n");
			return;
		}
		int handle = atoi(argv[2]);
		int actv_idx_str = atoi(argv[3]);
		bk_printf("idx:%d\r\n",actv_idx_str);
		if(actv_idx_str >= 0xFF){
			return;
		}
		conn_idx = actv_idx_str;
		unsigned char test_buf[4] = {0x01,0x02,0x22,0x32};
		if(handle >=0 && handle <= 0xFFFF){
			bk_ble_write_service_data_req(conn_idx,handle,4,test_buf);
		}else{
			bk_printf("handle(%x) error\r\n",handle);
		}
	}
}

static void ble_advertise_start(int argc, char **argv)
{
	uint8_t adv_data[31];
	uint8_t actv_idx;    
    uint8_t adv_data_len;

    ble_set_notice_cb(ble_notice_cb);
    ble_entry();
    bk_ble_init();    

	rt_thread_mdelay(10);

    actv_idx = app_ble_get_idle_actv_idx_handle(ADV_ACTV);
    bk_printf("actv_idx = %d\r\n",actv_idx);
	bk_ble_create_advertising(actv_idx, 7, 160, 160, ble_cmd_cb);

    adv_data[0] = 0x0A;
    adv_data[1] = 0x09;
    memcpy(&adv_data[2], "7252n_BLE", 9);

	rt_thread_mdelay(10);
    bk_ble_set_adv_data(actv_idx, adv_data, 11, ble_cmd_cb);

    adv_data[0] = 0x0A;
    adv_data[1] = 0x08;
    memcpy(&adv_data[2], "7252n_BLE", 9);

    #if (BLE_HID_DEVICE)
    adv_data[7] = 0x03;
    adv_data[8] = 0x03;
    adv_data[9] = 0x12;
    adv_data[10] = 0x18;
    adv_data_len = 0xB;
    #else
    adv_data_len = 11;
    #endif
	rt_thread_mdelay(10);
    bk_ble_set_scan_rsp_data(actv_idx, adv_data, adv_data_len, ble_cmd_cb);
    
	rt_thread_mdelay(10);
    bk_ble_start_advertising(actv_idx, 0, ble_cmd_cb);
}


void belon_ble_active() {
    ble_set_notice_cb(ble_notice_cb);
    ble_entry();
    bk_ble_init();
}
void belon_ble_init_scan() {
	uint8_t actv_idx; 
    struct scan_param scan_info;
    scan_info.channel_map = 7;
    scan_info.interval = 100;
    scan_info.window = 30;
    actv_idx = app_ble_get_idle_actv_idx_handle(SCAN_ACTV);
	bk_printf("actv_idx_scan : (%d) \r\n",actv_idx);
    bk_ble_scan_start(actv_idx, &scan_info, ble_cmd_cb);
}

void belon_ble_init_adv() {
	//uint8_t actv_idx; 
    struct adv_param adv_info;
    adv_info.channel_map = 7;
    adv_info.duration = 0;
    adv_info.prop = (1 << ADV_PROP_CONNECTABLE_POS) | (1 << ADV_PROP_SCANNABLE_POS);
    adv_info.interval_min = 160;
    adv_info.interval_max = 160;
    adv_info.advData[0] = 0x09;
    adv_info.advData[1] = 0x09;
    memcpy(&adv_info.advData[2], "7252nBLE", 8);
    adv_info.advDataLen = 10;
    adv_info.respData[0] = 0x06;
    adv_info.respData[1] = 0x08;
    memcpy(&adv_info.respData[2], "7252n", 5);
    adv_info.respDataLen = 7;
    actv_idx_adv = app_ble_get_idle_actv_idx_handle(ADV_ACTV);
	actv_idx_adv =1;
	bk_printf("actv_idx_adv : (%d) \r\n",actv_idx_adv);

	//bk_ble_create_advertising(actv_idx_adv, 7, 160, 160, ble_cmd_cb);
    bk_ble_adv_start(actv_idx_adv, &adv_info, ble_cmd_cb);
}

void belon_ble_scan_start() {
    bk_ble_start_scaning(0, 100, 30, ble_cmd_cb);
}

void belon_ble_scan_stop() {
    bk_ble_stop_scaning(0,ble_cmd_cb);
}
/*
	发起广播的参考指令
	step 1:ble active
	step 2:ble create_adv
	step 3:ble set_adv_data 0
	step 4:ble set_rsp_data 0
	step 5:ble start_adv 0 
*/
MSH_CMD_EXPORT(ble, ble command);

//直接发起广播参考指令：ble_advertise_start
MSH_CMD_EXPORT(ble_advertise_start, ble_advertise_start command);
#endif