/* BLE gatts module for coex demo This example code is in the Public Domain (or CC0 licensed, at your option.) Unless required by applicable law or agreed to in writing, this software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ #include #include "esp_log.h" #include "esp_gap_ble_api.h" #include "esp_gatts_api.h" #include "esp_gatt_common_api.h" #include "ble_gatts_module.h" #include "com_protocol.h" static const char *TAG = "BLE_GATTS"; static esp_bd_addr_t rand_addr = {0xC0, 0x30, 0x05, 0x70, 0x09,0xFA}; #define PROFILE_NUM 2 #define PROFILE_APP_IDX 0 // for app control #define PROFILE_UPDATE_IDX 1 // for update procedure #define ESP_APP_ID 0x55 #define SVC_INST_ID 0 #define SVC_INST_ID_UPDATE 1 /* The max length of characteristic value. When the GATT client performs a write or prepare write operation, * the data length must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX. */ #define GATTS_DEMO_CHAR_VAL_LEN_MAX 512 #define PREPARE_BUF_MAX_SIZE 1024 #define CHAR_DECLARATION_SIZE (sizeof(uint8_t)) #define ADV_CONFIG_FLAG (1 << 0) #define SCAN_RSP_CONFIG_FLAG (1 << 1) static uint8_t adv_config_done = 0; uint8_t ctrl_gatt_if= 0x00; uint16_t ctrl_conn_id = 0x00; bool is_ble_connected = false; uint16_t app_ctrl_handle_table[CTL_IDX_NB]; uint16_t app_update_handle_table[BUF_IDX_NB]; typedef struct { uint8_t *prepare_buf; int prepare_len; } prepare_type_env_t; static uint8_t raw_adv_data[] = { /* flags */ 0x02, 0x01, 0x06, /* tx power*/ 0x02, 0x0a, 0xeb, /* service uuid */ 0x03, 0x03, 0xFF, 0x00, /* device name */ 0x08, 0x09, 'B', 'S', '-', 'X', '0', '0', '1'}; static uint8_t raw_scan_rsp_data[] = { /* flags */ 0x02, 0x01, 0x06, /* tx power */ 0x02, 0x0a, 0xeb, /* service uuid */ 0x03, 0x03, 0xFF,0x00 }; static esp_ble_adv_params_t adv_params = { .adv_int_min = 0x20, .adv_int_max = 0x40, .adv_type = ADV_TYPE_IND, .own_addr_type = BLE_ADDR_TYPE_RANDOM, .channel_map = ADV_CHNL_ALL, .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY, }; struct gatts_profile_inst { esp_gatts_cb_t gatts_cb; uint16_t gatts_if; uint16_t app_id; uint16_t conn_id; uint16_t service_handle; esp_gatt_srvc_id_t service_id; uint16_t char_handle; esp_bt_uuid_t char_uuid; esp_gatt_perm_t perm; esp_gatt_char_prop_t property; uint16_t descr_handle; esp_bt_uuid_t descr_uuid; }; static void gatts_profile_ctrl_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param); static void gatts_profile_update_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param); /* One gatt-based profile one app_id and one gatts_if, this array will store the gatts_if returned by ESP_GATTS_REG_EVT */ static struct gatts_profile_inst bs_x001_profile_tab[PROFILE_NUM] = { [PROFILE_APP_IDX] = { .gatts_cb = gatts_profile_ctrl_event_handler, .gatts_if = ESP_GATT_IF_NONE, /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */ }, [PROFILE_UPDATE_IDX] = { .gatts_cb = gatts_profile_update_event_handler, .gatts_if = ESP_GATT_IF_NONE, /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */ }, }; //typedef bs_service_param* bs_service_param_handle; bs_service_param bs_service = { .mode = 0x00, .state = 0x00, .start = 0x00, .sleep_time = {23,00}, .wake_time = {7,00}, .fog_channel = 0x00, .sw_sleep_en = 0x01, .sw_wake_en = 0x01, .sw_slp_working_time = 30, .sw_wak_working_time = 20, .sw_slp_music = 0x1, .sw_slp_volume = 0x8, .sw_slp_light = 0x02, .sw_slp_fog = 0x01, .sw_wak_music = 0x01, .sw_wak_volume = 0x08, .sw_wak_light = 0x01, .sw_wak_fog = 0x01, .sw_snooze_time = 5, .nap_working_time_hour = 0x00, .nap_working_time_min = 30, .nap_sleep_en = 0x01, .nap_wake_en = 0x01, .nap_slp_working_time = 30, .nap_wak_working_time = 20, .nap_slp_music = 0x02, .nap_slp_volume = 0x08, .nap_slp_light = 0x02, .nap_slp_fog = 0x02, .nap_wak_music = 0x02, .nap_wak_volume = 0x02, .nap_wak_light = 0x01, .nap_wak_fog = 0x01, .med_working_time_hour = 0x00, .med_working_time_min = 20, .med_music = 0x03, .med_volume = 0x08, .med_light = 0x01, .med_fog = 0x01, .week_setting = {23,00,7,00,1,1,23,00,7,00,1,1,23,00,7,00,1,1,23,00,7,00,1,1,23,00,7,00,1,1,23,00,7,00,1,1,23,00,7,00,1,1}, .remain_time_hour = 0x00, .remain_time_min = 0x00, .cur_time = {21,1,1,2,0,0,0}, }; bs_update_param update_param; /* Service */ static const uint16_t GATTS_SERVICE_UUID_CTRL = 0x00FF; static const uint16_t GATTS_CHAR_UUID_MODE = 0xFF01; static const uint16_t GATTS_CHAR_UUID_STATE = 0xFF02; static const uint16_t GATTS_CHAR_UUID_START = 0xFF03; static const uint16_t GATTS_CHAR_UUID_SLP_T = 0xFF04; static const uint16_t GATTS_CHAR_UUID_WAK_T = 0xFF05; static const uint16_t GATTS_CHAR_UUID_FOG = 0xFF06; static const uint16_t GATTS_CHAR_UUID_SW = 0xFF07; static const uint16_t GATTS_CHAR_UUID_NAP = 0xFF08; static const uint16_t GATTS_CHAR_UUID_MED = 0xFF09; static const uint16_t GATTS_CHAR_UUID_WEEK = 0xFF0a; static const uint16_t GATTS_CHAR_UUID_VER = 0xFF0b; static const uint16_t GATTS_CHAR_UUID_TIME = 0xFF0c; //----UUID for update service------------------ static const uint16_t GATTS_SERVICE_UUID_UPDATE = 0x00FE; static const uint16_t GATTS_CHAR_UUID_UPDATE = 0xFE01; static const uint16_t GATTS_CHAR_UUID_NAME = 0xFE02; static const uint16_t GATTS_CHAR_UUID_LIST = 0xFE03; static const uint16_t GATTS_CHAR_UUID_VERSION = 0xFE04; static const uint16_t GATTS_CHAR_UUID_FM_UP = 0xFE05; static const uint16_t GATTS_CHAR_UUID_BUFF = 0xFE06; static const uint16_t primary_service_uuid = ESP_GATT_UUID_PRI_SERVICE; static const uint16_t character_declaration_uuid = ESP_GATT_UUID_CHAR_DECLARE; static const uint16_t character_client_config_uuid = ESP_GATT_UUID_CHAR_CLIENT_CONFIG; static const uint8_t char_prop_read_write_notify = ESP_GATT_CHAR_PROP_BIT_WRITE | ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_NOTIFY; uint8_t notify[18][2] ={{0x00,0x00}}; /* Full Database Description - Used to add attributes into the database */ static const esp_gatts_attr_db_t gatt_ctrl_db[CTL_IDX_NB] = { // Service Declaration [IDX_SVC] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(GATTS_SERVICE_UUID_CTRL), (uint8_t *)&GATTS_SERVICE_UUID_CTRL}}, /* Characteristic Declaration */ [IDX_CHAR_MODE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_MODE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_MODE, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&bs_service.mode}}, /* Client Characteristic Configuration Descriptor */ [IDX_CHAR_CFG_MODE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[0]), (uint8_t *)notify[0]}}, /* Characteristic Declaration */ [IDX_CHAR_STATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_STATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_STATE, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&bs_service.state}}, [IDX_CHAR_CFG_STATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[1]), (uint8_t *)notify[1]}}, /* Characteristic Declaration */ [IDX_CHAR_START] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_START] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_START, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&bs_service.start}}, [IDX_CHAR_CFG_START] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[2]), (uint8_t *)notify[2]}}, /* Characteristic Declaration */ [IDX_CHAR_FOG] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_FOG] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_FOG, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&bs_service.fog_channel}}, [IDX_CHAR_CFG_FOG] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[3]), (uint8_t *)notify[3]}}, /* Characteristic Declaration */ [IDX_CHAR_SLEEP_TIME]= {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_SLEEP_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_SLP_T, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&bs_service.sleep_time}}, [IDX_CHAR_CFG_SLEEP_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[4]), (uint8_t *)notify[4]}}, /* Characteristic Declaration */ [IDX_CHAR_WAKE_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_WAKE_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_WAK_T, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&bs_service.wake_time}}, [IDX_CHAR_CFG_WAKE_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[5]), (uint8_t *)notify[5]}}, /* Characteristic Declaration */ [IDX_CHAR_SW_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_SW_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_SW, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t)*13, (uint8_t *)&bs_service.sw_sleep_en}}, [IDX_CHAR_CFG_SW_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[6]), (uint8_t *)notify[6]}}, /* Characteristic Declaration */ [IDX_CHAR_NAP_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_NAP_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_NAP, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t)*14, (uint8_t *)&bs_service.nap_working_time_hour}}, [IDX_CHAR_CFG_NAP_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[7]), (uint8_t *)notify[7]}}, /* Characteristic Declaration */ [IDX_CHAR_MED_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_MED_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_MED, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t)*6, (uint8_t *)&bs_service.med_working_time_hour}}, [IDX_CHAR_CFG_MED_PARAM] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[8]), (uint8_t *)notify[8]}}, /* Characteristic Declaration */ [IDX_CHAR_WEEK_SETTING] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_WEEK_SETTING] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_WEEK, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(bs_service.week_setting), (uint8_t *)&bs_service.week_setting}}, [IDX_CHAR_CFG_WEEK_SETTING] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[9]), (uint8_t *)notify[9]}}, /* Characteristic Declaration */ [IDX_CHAR_REMAIN_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_REMAIN_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_VER, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t)*2, (uint8_t *)&bs_service.remain_time_hour}}, [IDX_CHAR_CFG_REMAIN_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[10]), (uint8_t *)notify[10]}}, [IDX_CHAR_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TIME, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t)*7, (uint8_t *)&bs_service.cur_time}}, [IDX_CHAR_CFG_TIME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[11]), (uint8_t *)notify[11]}}, }; static const esp_gatts_attr_db_t gatt_update_db[BUF_IDX_NB] = { [IDX_SVC_D] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ, sizeof(uint16_t), sizeof(GATTS_SERVICE_UUID_UPDATE), (uint8_t *)&GATTS_SERVICE_UUID_UPDATE}}, /* Characteristic Declaration */ [IDX_CHAR_MUS_UPDATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_MUS_UPDATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_UPDATE, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&update_param.fm_update_flag}}, [IDX_CHAR_CFG_MUS_UPDATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[12]), (uint8_t *)notify[12]}}, /* Characteristic Declaration */ [IDX_CHAR_MUS_NAME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_MUS_NAME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_NAME, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t)*16, (uint8_t *)update_param.music_name}}, [IDX_CHAR_CFG_MUS_NAME] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[13]), (uint8_t *)notify[13]}}, /* Characteristic Declaration */ [IDX_CHAR_MUS_LIST] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_MUS_LIST] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_LIST, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t)*128, (uint8_t *)update_param.music_list}}, [IDX_CHAR_CFG_MUS_LIST] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[14]), (uint8_t *)notify[14]}}, /* Characteristic Declaration */ [IDX_CHAR_FM_VERSION] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_FM_VERSION] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_VERSION, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&update_param.fm_version}}, [IDX_CHAR_CFG_FM_VERSION] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[15]), (uint8_t *)notify[15]}}, /* Characteristic Declaration */ [IDX_CHAR_FM_UPDATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_FM_UPDATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_FM_UP, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)&update_param.fm_update_flag}}, [IDX_CHAR_CFG_FM_UPDATE] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[16]), (uint8_t *)notify[16]}}, /* Characteristic Declaration */ [IDX_CHAR_BUF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, /* Characteristic Value */ [IDX_CHAR_VAL_BUF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_BUFF, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(uint8_t), (uint8_t *)update_param.update_buf}}, [IDX_CHAR_CFG_BUF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(notify[17]), (uint8_t *)notify[17]}}, }; static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) { switch (event) { case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT: adv_config_done &= (~ADV_CONFIG_FLAG); if (adv_config_done == 0) { esp_ble_gap_start_advertising(&adv_params); } break; case ESP_GAP_BLE_SCAN_RSP_DATA_RAW_SET_COMPLETE_EVT: adv_config_done &= (~SCAN_RSP_CONFIG_FLAG); if (adv_config_done == 0) { esp_ble_gap_start_advertising(&adv_params); } break; case ESP_GAP_BLE_ADV_START_COMPLETE_EVT: /* advertising start complete event to indicate advertising start successfully or failed */ if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) { ESP_LOGE(TAG, "advertising start failed"); } else { ESP_LOGI(TAG, "advertising start successfully"); } break; case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT: if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS) { ESP_LOGE(TAG, "Advertising stop failed"); } else { ESP_LOGI(TAG, "Stop adv successfully\n"); } break; case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT: ESP_LOGI(TAG,"switch is ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT"); ESP_LOGI(TAG, "update connection params status = %d, min_int = %d, max_int = %d,conn_int = %d,latency = %d, timeout = %d", param->update_conn_params.status, param->update_conn_params.min_int, param->update_conn_params.max_int, param->update_conn_params.conn_int, param->update_conn_params.latency, param->update_conn_params.timeout); break; default: break; } } static void example_prepare_write_event_env(esp_gatt_if_t gatts_if, prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param) { ESP_LOGI(TAG, "prepare write, handle = %d, value len = %d", param->write.handle, param->write.len); esp_gatt_status_t status = ESP_GATT_OK; if (prepare_write_env->prepare_buf == NULL) { prepare_write_env->prepare_buf = (uint8_t *)malloc(PREPARE_BUF_MAX_SIZE * sizeof(uint8_t)); prepare_write_env->prepare_len = 0; if (prepare_write_env->prepare_buf == NULL) { ESP_LOGE(TAG, "%s, Gatt_server prep no mem", __func__); status = ESP_GATT_NO_RESOURCES; } } else { if (param->write.offset > PREPARE_BUF_MAX_SIZE) { status = ESP_GATT_INVALID_OFFSET; } else if ((param->write.offset + param->write.len) > PREPARE_BUF_MAX_SIZE) { status = ESP_GATT_INVALID_ATTR_LEN; } } /*send response when param->write.need_rsp is true */ if (param->write.need_rsp) { esp_gatt_rsp_t *gatt_rsp = (esp_gatt_rsp_t *)malloc(sizeof(esp_gatt_rsp_t)); if (gatt_rsp != NULL){ gatt_rsp->attr_value.len = param->write.len; gatt_rsp->attr_value.handle = param->write.handle; gatt_rsp->attr_value.offset = param->write.offset; gatt_rsp->attr_value.auth_req = ESP_GATT_AUTH_REQ_NONE; memcpy(gatt_rsp->attr_value.value, param->write.value, param->write.len); esp_err_t response_err = esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, status, gatt_rsp); if (response_err != ESP_OK) { ESP_LOGE(TAG, "Send response error"); } free(gatt_rsp); } else { ESP_LOGE(TAG, "%s, malloc failed", __func__); } } if (status != ESP_GATT_OK) { return; } memcpy(prepare_write_env->prepare_buf + param->write.offset, param->write.value, param->write.len); prepare_write_env->prepare_len += param->write.len; } static void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param) { if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC && prepare_write_env->prepare_buf) { esp_log_buffer_hex(TAG, prepare_write_env->prepare_buf, prepare_write_env->prepare_len); } else { ESP_LOGI(TAG,"ESP_GATT_PREP_WRITE_CANCEL"); } if (prepare_write_env->prepare_buf) { free(prepare_write_env->prepare_buf); prepare_write_env->prepare_buf = NULL; } prepare_write_env->prepare_len = 0; } extern void BLE_GATT_control_datas_handler(esp_gatt_if_t gatt_if,uint16_t conn_id,uint16_t handle,uint8_t* datas,uint8_t len); extern void BLE_GATT_control_read_handler(esp_gatt_if_t gatt_if,uint16_t conn_id,uint16_t handle,uint32_t trans_id); static void gatts_profile_ctrl_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) { prepare_type_env_t prepare_write_env; switch (event) { case ESP_GATTS_REG_EVT: ESP_LOGE(TAG, "ESP_GATTS_REG_EVT,gatts_profile_ctrl_event_handler"); esp_ble_gap_set_rand_addr(rand_addr); esp_err_t raw_adv_ret = esp_ble_gap_config_adv_data_raw(raw_adv_data, sizeof(raw_adv_data)); if (raw_adv_ret){ ESP_LOGE(TAG, "config raw adv data failed, error code = %x ", raw_adv_ret); } adv_config_done |= ADV_CONFIG_FLAG; esp_err_t raw_scan_ret = esp_ble_gap_config_scan_rsp_data_raw(raw_scan_rsp_data, sizeof(raw_scan_rsp_data)); if (raw_scan_ret){ ESP_LOGE(TAG, "config raw scan rsp data failed, error code = %x", raw_scan_ret); } adv_config_done |= SCAN_RSP_CONFIG_FLAG; esp_err_t create_attr_ret = esp_ble_gatts_create_attr_tab(gatt_ctrl_db, gatts_if, CTL_IDX_NB, SVC_INST_ID); if (create_attr_ret){ ESP_LOGE(TAG, "create attr table failed, error code = %x", create_attr_ret); } break; case ESP_GATTS_READ_EVT: ESP_LOGI(TAG, "ESP_GATTS_READ_EVT"); ESP_LOGI(TAG, "conn_id is %x,handle is %x,trans_id is %d",param->read.conn_id,param->read.handle,param->read.trans_id); //BLE_GATT_control_read_handler(gatts_if,param->read.conn_id,param->read.handle,param->read.trans_id); break; case ESP_GATTS_WRITE_EVT: if (!param->write.is_prep) { // the data length of gattc write must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX. ESP_LOGI(TAG, "GATT_WRITE_EVT for ctrl, handle = %d, value len = %d, value :", param->write.handle, param->write.len); esp_log_buffer_hex(TAG, param->write.value, param->write.len); /*User data analysis code*/ BLE_GATT_control_datas_handler(gatts_if,param->write.conn_id,param->write.handle,param->write.value,param->write.len); /* send response when param->write.need_rsp is true*/ ESP_LOGI(TAG, "need respond is %x",param->write.need_rsp); if (param->write.need_rsp) { esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL); } } else { /* handle prepare write */ example_prepare_write_event_env(gatts_if, &prepare_write_env, param); } break; case ESP_GATTS_EXEC_WRITE_EVT: // the length of gattc prepare write data must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX. ESP_LOGI(TAG, "ESP_GATTS_EXEC_WRITE_EVT"); example_exec_write_event_env(&prepare_write_env, param); break; case ESP_GATTS_MTU_EVT: ESP_LOGI(TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu); break; case ESP_GATTS_CONF_EVT: ESP_LOGI(TAG, "ESP_GATTS_CONF_EVT, status = %d, attr_handle %d", param->conf.status, param->conf.handle); break; case ESP_GATTS_START_EVT: ESP_LOGI(TAG, "SERVICE_START_EVT, status %d, service_handle %d", param->start.status, param->start.service_handle); break; case ESP_GATTS_CONNECT_EVT: ESP_LOGI(TAG, "ESP_GATTS_CONNECT_EVT, conn_id = %d", param->connect.conn_id); esp_ble_gap_stop_advertising(); esp_log_buffer_hex(TAG, param->connect.remote_bda, 6); esp_ble_conn_update_params_t conn_params = {0}; memcpy(conn_params.bda, param->connect.remote_bda, sizeof(esp_bd_addr_t)); /* For the iOS system, please refer to Apple official documents about the BLE connection parameters restrictions. */ conn_params.latency = 0; conn_params.max_int = 0x40; // max_int = 0x20*1.25ms = 40ms conn_params.min_int = 0x20; // min_int = 0x10*1.25ms = 20ms conn_params.timeout = 800; // timeout = 400*10ms = 4000ms //start sent the update connection parameters to the peer device. esp_ble_gap_update_conn_params(&conn_params); ctrl_gatt_if = gatts_if; ctrl_conn_id = param->connect.conn_id; is_ble_connected = true; ReportBtConnectionState(); break; case ESP_GATTS_DISCONNECT_EVT: ESP_LOGI(TAG, "ESP_GATTS_DISCONNECT_EVT, reason = 0x%x", param->disconnect.reason); esp_ble_gap_start_advertising(&adv_params); is_ble_connected = false; ReportBtConnectionState(); break; case ESP_GATTS_CREAT_ATTR_TAB_EVT:{ if (param->add_attr_tab.status != ESP_GATT_OK) { ESP_LOGE(TAG, "create attribute table failed, error code=0x%x", param->add_attr_tab.status); } else if (param->add_attr_tab.num_handle != CTL_IDX_NB) { ESP_LOGE(TAG, "create attribute table abnormally, num_handle (%d) \ doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, CTL_IDX_NB); } else { ESP_LOGI(TAG, "create attribute table successfully, the number handle = %d\n",param->add_attr_tab.num_handle); memcpy(app_ctrl_handle_table, param->add_attr_tab.handles, sizeof(app_ctrl_handle_table)); esp_ble_gatts_start_service(app_ctrl_handle_table[IDX_SVC]); } break; } case ESP_GATTS_STOP_EVT: case ESP_GATTS_OPEN_EVT: case ESP_GATTS_CANCEL_OPEN_EVT: case ESP_GATTS_CLOSE_EVT: case ESP_GATTS_LISTEN_EVT: case ESP_GATTS_CONGEST_EVT: case ESP_GATTS_UNREG_EVT: case ESP_GATTS_DELETE_EVT: default: break; } } extern void BLE_GATT_update_read_handler(esp_gatt_if_t gatt_if,uint16_t conn_id,uint16_t handle,uint32_t trans_id); extern void BLE_GATT_update_datas_handler(esp_gatt_if_t gatts_if,uint16_t conn_id,uint16_t handle,uint8_t* datas,uint8_t len); static void gatts_profile_update_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) { prepare_type_env_t prepare_write_env; switch (event) { case ESP_GATTS_REG_EVT: { esp_err_t create_attr_ret = esp_ble_gatts_create_attr_tab(gatt_update_db, gatts_if, BUF_IDX_NB, SVC_INST_ID_UPDATE); if (create_attr_ret){ ESP_LOGE(TAG, "create attr table failed, error code = %x", create_attr_ret); } } break; case ESP_GATTS_READ_EVT: ESP_LOGI(TAG, "UPDATE_ESP_GATTS_READ_EVT"); //BLE_GATT_update_read_handler(gatts_if,param->read.conn_id ,param->read.handle,param->read.trans_id); break; case ESP_GATTS_WRITE_EVT: if (!param->write.is_prep) { // the data length of gattc write must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX. ESP_LOGI(TAG, "GATT_WRITE_EVT for update, handle = %d, value len = %d, value :", param->write.handle, param->write.len); esp_log_buffer_hex(TAG, param->write.value, param->write.len); BLE_GATT_update_datas_handler(gatts_if,param->write.conn_id,param->write.handle,param->write.value,param->write.len); /* send response when param->write.need_rsp is true*/ if (param->write.need_rsp) { esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL); } } else { /* handle prepare write */ example_prepare_write_event_env(gatts_if, &prepare_write_env, param); } break; case ESP_GATTS_EXEC_WRITE_EVT: // the length of gattc prepare write data must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX. ESP_LOGI(TAG, "ESP_GATTS_EXEC_WRITE_EVT"); example_exec_write_event_env(&prepare_write_env, param); break; case ESP_GATTS_MTU_EVT: ESP_LOGI(TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu); break; case ESP_GATTS_CONF_EVT: ESP_LOGI(TAG, "ESP_GATTS_CONF_EVT, status = %d, attr_handle %d", param->conf.status, param->conf.handle); break; case ESP_GATTS_START_EVT: ESP_LOGI(TAG, "SERVICE_START_EVT, status %d, service_handle %d", param->start.status, param->start.service_handle); break; case ESP_GATTS_CONNECT_EVT: ESP_LOGI(TAG, "ESP_GATTS_CONNECT_EVT, conn_id = %d", param->connect.conn_id); esp_ble_gap_stop_advertising(); esp_log_buffer_hex(TAG, param->connect.remote_bda, 6); esp_ble_conn_update_params_t conn_params = {0}; memcpy(conn_params.bda, param->connect.remote_bda, sizeof(esp_bd_addr_t)); conn_params.latency = 0; conn_params.max_int = 0x40; // max_int = 0x20*1.25ms = 40ms conn_params.min_int = 0x20; // min_int = 0x10*1.25ms = 20ms conn_params.timeout = 800; // timeout = 400*10ms = 4000ms //start sent the update connection parameters to the peer device. esp_ble_gap_update_conn_params(&conn_params); break; case ESP_GATTS_DISCONNECT_EVT: ESP_LOGI(TAG, "ESP_GATTS_DISCONNECT_EVT, reason = 0x%x", param->disconnect.reason); esp_ble_gap_start_advertising(&adv_params); break; case ESP_GATTS_CREAT_ATTR_TAB_EVT:{ if (param->add_attr_tab.status != ESP_GATT_OK) { ESP_LOGE(TAG, "create attribute table failed, error code=0x%x", param->add_attr_tab.status); } else if (param->add_attr_tab.num_handle != BUF_IDX_NB) { ESP_LOGE(TAG, "create attribute table abnormally, num_handle (%d) \ doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, BUF_IDX_NB); } else { ESP_LOGI(TAG, "create attribute table successfully, the number handle = %d\n",param->add_attr_tab.num_handle); memcpy(app_update_handle_table, param->add_attr_tab.handles, sizeof(app_update_handle_table)); esp_ble_gatts_start_service(app_update_handle_table[IDX_SVC_D]); } break; } case ESP_GATTS_STOP_EVT: case ESP_GATTS_OPEN_EVT: case ESP_GATTS_CANCEL_OPEN_EVT: case ESP_GATTS_CLOSE_EVT: case ESP_GATTS_LISTEN_EVT: case ESP_GATTS_CONGEST_EVT: case ESP_GATTS_UNREG_EVT: case ESP_GATTS_DELETE_EVT: default: break; } } static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) { /* If event is register event, store the gatts_if for each profile */ if (event == ESP_GATTS_REG_EVT) { if (param->reg.status == ESP_GATT_OK) { bs_x001_profile_tab[param->reg.app_id].gatts_if = gatts_if; } else { ESP_LOGE(TAG, "reg app failed, app_id %04x, status %d", param->reg.app_id, param->reg.status); return; } } int idx; for (idx = 0; idx < PROFILE_NUM; idx++) { /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */ if (gatts_if == ESP_GATT_IF_NONE || gatts_if == bs_x001_profile_tab[idx].gatts_if) { if (bs_x001_profile_tab[idx].gatts_cb) { bs_x001_profile_tab[idx].gatts_cb(event, gatts_if, param); } } } } esp_err_t ble_gatts_module_init(void) { esp_log_level_set(TAG, ESP_LOG_INFO); ESP_LOGI(TAG, "ble gatts module init"); ESP_LOGI(TAG, "Characteristic declear value is %x", char_prop_read_write_notify); esp_err_t ret = esp_ble_gatts_register_callback(gatts_event_handler); if (ret) { ESP_LOGE(TAG, "gatts register error, error code = %x", ret); return ESP_FAIL; } ret = esp_ble_gap_register_callback(gap_event_handler); if (ret) { ESP_LOGE(TAG, "gap register error, error code = %x", ret); return ESP_FAIL; } ret = esp_ble_gatts_app_register(PROFILE_APP_IDX); if (ret) { ESP_LOGE(TAG, "gatts app register error, error code = %x", ret); return ESP_FAIL; } ret = esp_ble_gatts_app_register(PROFILE_UPDATE_IDX); if (ret) { ESP_LOGE(TAG, "gatts app register error, error code = %x", ret); return ESP_FAIL; } esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(512); if (local_mtu_ret) { ESP_LOGE(TAG, "set local MTU failed, error code = %x", local_mtu_ret); return ESP_FAIL; } return ESP_OK; }