429 lines
13 KiB
C
429 lines
13 KiB
C
/*
|
|
* Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
|
|
* Licensed under the MIT License (the "License"); you may not use this file except in
|
|
* compliance with the License. You may obtain a copy of the License at
|
|
* http://opensource.org/licenses/MIT
|
|
* Unless required by applicable law or agreed to in writing, software distributed under the License is
|
|
* distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
|
|
* either express or implied. See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*/
|
|
|
|
// #include "nrf52832_xxaa_service.h"
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
|
|
#include "ble_qiot_import.h"
|
|
|
|
// #include "host/ble_hs.h"
|
|
// #include "host/ble_uuid.h"
|
|
#include "host/ble_gap.h"
|
|
#include "host/ble_gatt.h"
|
|
|
|
#include "flash_storage.h"
|
|
#include "ble_qiot_log.h"
|
|
|
|
|
|
// divece configs
|
|
// this only for reference, please create your own device and replace it!
|
|
// https://cloud.tencent.com/product/iotexplorer
|
|
// #define PRODUCT_ID "PRODUCT_ID" // 10 Bytes
|
|
// #define DEVICE_NAME "YOUR_DEVICE_NAME" // equal or lesser than 48 Bytes
|
|
// #define SECRET_KEY "YOUR_PRODUCT_SECRET_KEY_" // 24 Bytes
|
|
|
|
#define PRODUCT_ID "RF1EOUKV5C"
|
|
#define DEVICE_NAME "ble_device_02"
|
|
#define SECRET_KEY "3zDmA91czLhz9+XsuPeSzw=="
|
|
|
|
#define ADV_DEVICE_NAME "tos_llsync"
|
|
|
|
|
|
#define IOT_BLE_UUID_BASE96 0xe2, 0xa4, 0x1b, 0x54, 0x93, 0xe4, 0x6a, 0xb5, \
|
|
0x20, 0x4e, 0xd0, 0x65
|
|
|
|
#define UINT16_TO_BYTES(n) ((uint8_t) (n)), ((uint8_t)((n) >> 8))
|
|
#define UINT32_TO_BYTES(n) ((uint8_t) (n)), ((uint8_t)((n) >> 8)), ((uint8_t)((n) >> 16)), ((uint8_t)((n) >> 24))
|
|
|
|
#define UINT16_TO_UUID32(n) ((uint8_t) (n)), ((uint8_t)((n) >> 8)), ((uint8_t)((n) >> 16)), ((uint8_t)((n) >> 24))
|
|
#define IOT_BLE_UUID128_BUILD(uuid) IOT_BLE_UUID_BASE96, UINT16_TO_UUID32(uuid)
|
|
|
|
#define IOT_BLE_UUID128_SERVICE IOT_BLE_UUID128_BUILD(IOT_BLE_UUID_SERVICE)
|
|
#define IOT_BLE_UUID128_DEVICE_INFO IOT_BLE_UUID128_BUILD(IOT_BLE_UUID_DEVICE_INFO)
|
|
#define IOT_BLE_UUID128_DATA IOT_BLE_UUID128_BUILD(IOT_BLE_UUID_DATA)
|
|
#define IOT_BLE_UUID128_EVENT IOT_BLE_UUID128_BUILD(IOT_BLE_UUID_EVENT)
|
|
|
|
static ble_uuid128_t ble_uuid128_t_service = BLE_UUID128_INIT(IOT_BLE_UUID128_SERVICE);
|
|
static ble_uuid128_t ble_uuid128_t_device_info = BLE_UUID128_INIT(IOT_BLE_UUID128_DEVICE_INFO);
|
|
static ble_uuid128_t ble_uuid128_t_data = BLE_UUID128_INIT(IOT_BLE_UUID128_DATA);
|
|
static ble_uuid128_t ble_uuid128_t_event = BLE_UUID128_INIT(IOT_BLE_UUID128_EVENT);
|
|
|
|
static uint16_t qiot_gap_connect_handle;
|
|
|
|
static uint16_t qiot_device_info_handle;
|
|
static uint16_t qiot_data_handle;
|
|
static uint16_t qiot_event_handle;
|
|
|
|
static int ble_svc_qiot_access(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg);
|
|
|
|
// LLsync BLE services and characteristics
|
|
static const struct ble_gatt_svc_def ble_svc_qiot_defs[] = {
|
|
{
|
|
.type = BLE_GATT_SVC_TYPE_PRIMARY,
|
|
.uuid = &ble_uuid128_t_service.u,
|
|
// .uuid = BLE_UUID16_DECLARE(IOT_BLE_UUID_SERVICE),
|
|
.characteristics = (struct ble_gatt_chr_def[]) {
|
|
{
|
|
.uuid = &ble_uuid128_t_device_info.u,
|
|
// .uuid = BLE_UUID16_DECLARE(IOT_BLE_UUID_DEVICE_INFO),
|
|
.access_cb = ble_svc_qiot_access,
|
|
// .val_handle = &qiot_device_info_handle,
|
|
// .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_WRITE_NO_RSP,
|
|
.flags = BLE_GATT_CHR_F_WRITE_NO_RSP,
|
|
// .flags = 0xFFF,
|
|
},
|
|
{
|
|
.uuid = &ble_uuid128_t_data.u,
|
|
// .uuid = BLE_UUID16_DECLARE(IOT_BLE_UUID_DATA),
|
|
.access_cb = ble_svc_qiot_access,
|
|
// .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_WRITE_NO_RSP,
|
|
.flags = BLE_GATT_CHR_F_WRITE_NO_RSP,
|
|
},
|
|
{
|
|
.uuid = &ble_uuid128_t_event.u,
|
|
// .uuid = BLE_UUID16_DECLARE(IOT_BLE_UUID_EVENT),
|
|
.access_cb = ble_svc_qiot_access,
|
|
.val_handle = &qiot_event_handle,
|
|
.flags = BLE_GATT_CHR_F_NOTIFY,
|
|
},
|
|
|
|
// end of characteristics
|
|
{.uuid = 0},
|
|
},
|
|
},
|
|
|
|
// end of services
|
|
{.type = 0},
|
|
};
|
|
|
|
static int ble_svc_qiot_access(uint16_t conn_handle, uint16_t attr_handle,
|
|
struct ble_gatt_access_ctxt *ctxt, void *arg)
|
|
{
|
|
const ble_uuid_t *uuid;
|
|
// int rand_num;
|
|
int rc, ret;
|
|
uint16_t len = 0;
|
|
uint8_t buf[256] = {0};
|
|
|
|
uuid = ctxt->chr->uuid;
|
|
|
|
if(ble_uuid_cmp(uuid, &ble_uuid128_t_device_info.u) == 0)
|
|
{
|
|
switch (ctxt->op)
|
|
{
|
|
case BLE_GATT_ACCESS_OP_WRITE_CHR:
|
|
rc = ble_hs_mbuf_to_flat(ctxt->om, buf, sizeof(buf), &len);
|
|
if (rc != 0)
|
|
{
|
|
ble_qiot_log_e("ble att err, ret: %d", ret);
|
|
return BLE_ATT_ERR_UNLIKELY;
|
|
}
|
|
ble_qiot_log_hex(BLE_QIOT_LOG_LEVEL_DEBUG, "device info raw", (char *)buf, len);
|
|
ble_device_info_write_cb(buf, len);
|
|
default:
|
|
return BLE_ATT_ERR_UNLIKELY;
|
|
}
|
|
}
|
|
else if(ble_uuid_cmp(uuid, &ble_uuid128_t_data.u) == 0)
|
|
{
|
|
switch (ctxt->op)
|
|
{
|
|
case BLE_GATT_ACCESS_OP_WRITE_CHR:
|
|
rc = ble_hs_mbuf_to_flat(ctxt->om, buf, sizeof(buf), &len);
|
|
if (rc != 0)
|
|
{
|
|
ble_qiot_log_e("ble att err, ret: %d", ret);
|
|
return BLE_ATT_ERR_UNLIKELY;
|
|
}
|
|
ble_qiot_log_hex(BLE_QIOT_LOG_LEVEL_DEBUG, "lldata raw", (char *)buf, len);
|
|
ble_lldata_write_cb(buf, len);
|
|
default:
|
|
return BLE_ATT_ERR_UNLIKELY;
|
|
}
|
|
}
|
|
else if(ble_uuid_cmp(uuid, &ble_uuid128_t_event.u) == 0)
|
|
{
|
|
// this characteristic not have read or write attribute
|
|
}
|
|
else
|
|
{
|
|
ble_qiot_log_e("unknown service or characteristic");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// add services and characteristic
|
|
void ble_services_add(const qiot_service_init_s *p_service)
|
|
{
|
|
int ret = 0;
|
|
|
|
ret = ble_gatts_count_cfg(ble_svc_qiot_defs);
|
|
if(ret != 0)
|
|
{
|
|
ble_qiot_log_e("ble_gatts_count_cfg() err, ret: %d", ret);
|
|
}
|
|
|
|
ret = ble_gatts_add_svcs(ble_svc_qiot_defs);
|
|
if(ret != 0)
|
|
{
|
|
ble_qiot_log_e("ble_gatts_add_svcs() err, ret: %d", ret);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
int ble_get_product_id(char *product_id)
|
|
{
|
|
memcpy(product_id, PRODUCT_ID, strlen(PRODUCT_ID));
|
|
return 0;
|
|
}
|
|
|
|
int ble_get_device_name(char *device_name)
|
|
{
|
|
memcpy(device_name, DEVICE_NAME, strlen(DEVICE_NAME));
|
|
return strlen(DEVICE_NAME);
|
|
}
|
|
|
|
int ble_get_psk(char *psk)
|
|
{
|
|
memcpy(psk, SECRET_KEY, strlen(SECRET_KEY));
|
|
return 0;
|
|
}
|
|
|
|
int ble_get_mac(char *mac)
|
|
{
|
|
memcpy(mac, MYNEWT_VAL_BLE_PUBLIC_DEV_ADDR, sizeof(MYNEWT_VAL_BLE_PUBLIC_DEV_ADDR));
|
|
ble_qiot_log_hex(BLE_QIOT_LOG_LEVEL_DEBUG, "mac_addr", mac, 6);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ble_write_flash(uint32_t flash_addr, const char *write_buf, uint16_t write_len)
|
|
{
|
|
return fstorage_write(flash_addr, write_len, write_buf);
|
|
}
|
|
|
|
int ble_read_flash(uint32_t flash_addr, char *read_buf, uint16_t read_len)
|
|
{
|
|
return fstorage_read(flash_addr, read_len, read_buf);
|
|
}
|
|
|
|
int ble_qiot_gap_event_fn(struct ble_gap_event *event, void *arg)
|
|
{
|
|
ble_qiot_log_d("get event, type: %d", event->type);
|
|
|
|
switch (event->type) {
|
|
case BLE_GAP_EVENT_CONNECT:
|
|
/* A new connection was established or a connection attempt failed */
|
|
MODLOG_DFLT(INFO, "connection %s; status=%d\n",
|
|
event->connect.status == 0 ? "established" : "failed",
|
|
event->connect.status);
|
|
|
|
if (event->connect.status != 0) {
|
|
/* Connection failed; resume advertising */
|
|
ble_qiot_advertising_start();
|
|
qiot_gap_connect_handle = 0;
|
|
}
|
|
else
|
|
{
|
|
qiot_gap_connect_handle = event->connect.conn_handle;
|
|
}
|
|
|
|
break;
|
|
|
|
case BLE_GAP_EVENT_DISCONNECT:
|
|
MODLOG_DFLT(INFO, "disconnect; reason=%d\n", event->disconnect.reason);
|
|
|
|
/* Connection terminated; resume advertising */
|
|
ble_qiot_advertising_start();
|
|
qiot_gap_connect_handle = 0;
|
|
break;
|
|
|
|
case BLE_GAP_EVENT_ADV_COMPLETE:
|
|
MODLOG_DFLT(INFO, "adv complete\n");
|
|
ble_qiot_advertising_start();
|
|
break;
|
|
|
|
// case BLE_GAP_EVENT_SUBSCRIBE:
|
|
// MODLOG_DFLT(INFO, "subscribe event; cur_notify=%d\n value handle; "
|
|
// "val_handle=%d\n",
|
|
// event->subscribe.cur_notify, hrs_hrm_handle);
|
|
// if (event->subscribe.attr_handle == hrs_hrm_handle) {
|
|
// notify_state = event->subscribe.cur_notify;
|
|
// notify_conn_handle = event->subscribe.conn_handle;
|
|
// blehr_tx_hrate_reset();
|
|
// } else if (event->subscribe.attr_handle != hrs_hrm_handle) {
|
|
// notify_state = event->subscribe.cur_notify;
|
|
// notify_conn_handle = 0;
|
|
// blehr_tx_hrate_stop();
|
|
// }
|
|
// break;
|
|
|
|
case BLE_GAP_EVENT_MTU:
|
|
MODLOG_DFLT(INFO, "mtu update event; conn_handle=%d mtu=%d\n",
|
|
event->mtu.conn_handle,
|
|
event->mtu.value);
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
#define ADV_MAX_UUID16_NUM 15
|
|
static uint8_t ble_addr_type;
|
|
|
|
ble_qiot_ret_status_t ble_advertising_start(adv_info_s *adv)
|
|
{
|
|
int ret = 0, i = 0;
|
|
struct ble_gap_adv_params adv_params;
|
|
struct ble_hs_adv_fields fields;
|
|
struct ble_hs_adv_fields rsp_fields;
|
|
uint8_t adv_manufacture_data[32] = {0};
|
|
ble_uuid16_t adv_uuids16_list[ADV_MAX_UUID16_NUM];
|
|
|
|
memset(&fields, 0, sizeof(fields));
|
|
memset(&rsp_fields, 0, sizeof(rsp_fields));
|
|
|
|
// set advertising data
|
|
/* Advertise two flags:
|
|
* o Discoverability in forthcoming advertisement (general)
|
|
* o BLE-only (BR/EDR unsupported).
|
|
*/
|
|
fields.flags = BLE_HS_ADV_F_DISC_GEN |
|
|
BLE_HS_ADV_F_BREDR_UNSUP;
|
|
|
|
// fields.uuids16 = (ble_uuid16_t)adv->uuid_info.uuids;??
|
|
if (adv->uuid_info.uuid_num > ADV_MAX_UUID16_NUM)
|
|
{
|
|
printf("err: too many uuids16 in adv data! (uuids num %d)\r\n", adv->uuid_info.uuid_num);
|
|
return BLE_QIOT_RS_ERR;
|
|
}
|
|
|
|
for (i=0; i<adv->uuid_info.uuid_num; i++)
|
|
{
|
|
adv_uuids16_list[i].u.type = BLE_UUID_TYPE_16;
|
|
adv_uuids16_list[i].value = adv->uuid_info.uuids[i];
|
|
}
|
|
fields.uuids16 = adv_uuids16_list;
|
|
fields.num_uuids16 = adv->uuid_info.uuid_num;
|
|
fields.uuids16_is_complete = 1;
|
|
|
|
memcpy(&adv_manufacture_data[0], (uint8_t *)&adv->manufacturer_info.company_identifier, 2);
|
|
memcpy(&adv_manufacture_data[2], adv->manufacturer_info.adv_data, adv->manufacturer_info.adv_data_len);
|
|
fields.mfg_data = adv_manufacture_data;
|
|
fields.mfg_data_len = adv->manufacturer_info.adv_data_len + 2;
|
|
|
|
ret = ble_gap_adv_set_fields(&fields);
|
|
if (ret != 0)
|
|
{
|
|
ble_qiot_log_e("ble_gap_adv_set_fields() err, ret: %d", ret);
|
|
return BLE_QIOT_RS_ERR;
|
|
}
|
|
|
|
// set advertising respond data
|
|
rsp_fields.name = ADV_DEVICE_NAME;
|
|
rsp_fields.name_len = strlen(ADV_DEVICE_NAME);
|
|
rsp_fields.name_is_complete = 1;
|
|
ret = ble_gap_adv_rsp_set_fields(&rsp_fields);
|
|
if(ret != 0)
|
|
{
|
|
ble_qiot_log_e("ble_gap_adv_rsp_set_fields() err, ret: %d", ret);
|
|
return BLE_QIOT_RS_ERR;
|
|
}
|
|
|
|
ret = ble_hs_id_infer_auto(0, &ble_addr_type);
|
|
if (ret != 0)
|
|
{
|
|
ble_qiot_log_e("ble_hs_id_infer_auto() err, ret: %d", ret);
|
|
return BLE_QIOT_RS_ERR;
|
|
}
|
|
|
|
memset(&adv_params, 0, sizeof adv_params);
|
|
adv_params.conn_mode = BLE_GAP_CONN_MODE_UND;
|
|
adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN;
|
|
ret = ble_gap_adv_start(ble_addr_type, NULL, BLE_HS_FOREVER,
|
|
&adv_params, ble_qiot_gap_event_fn, NULL);
|
|
if (ret != 0)
|
|
{
|
|
ble_qiot_log_e("ble_gap_adv_start() err, ret: %d", ret);
|
|
return BLE_QIOT_RS_ERR;
|
|
}
|
|
|
|
return BLE_QIOT_RS_OK;
|
|
}
|
|
|
|
ble_qiot_ret_status_t ble_advertising_stop(void)
|
|
{
|
|
int ret = 0;
|
|
|
|
ble_gap_adv_stop();
|
|
if(ret != 0)
|
|
{
|
|
ble_qiot_log_e("ble_gap_adv_stop() err, ret: %d", ret);
|
|
return BLE_QIOT_RS_ERR;
|
|
}
|
|
|
|
return BLE_QIOT_RS_OK;
|
|
}
|
|
|
|
ble_qiot_ret_status_t ble_send_notify(uint8_t *buf, uint8_t len)
|
|
{
|
|
struct os_mbuf *om;
|
|
int rc = 0;
|
|
|
|
om = ble_hs_mbuf_from_flat(buf, len);
|
|
|
|
rc = ble_gattc_notify_custom(qiot_gap_connect_handle, qiot_event_handle, om);
|
|
if(rc)
|
|
{
|
|
ble_qiot_log_e("send notify err, return %d", rc);
|
|
return BLE_QIOT_RS_ERR;
|
|
}
|
|
|
|
return BLE_QIOT_RS_OK;
|
|
}
|
|
|
|
ble_timer_t ble_timer_create(uint8_t type, ble_timer_cb timeout_handle)
|
|
{
|
|
return (ble_timer_t)NULL;
|
|
}
|
|
|
|
ble_qiot_ret_status_t ble_timer_start(ble_timer_t timer_id, uint32_t period)
|
|
{
|
|
return BLE_QIOT_RS_OK;
|
|
}
|
|
|
|
ble_qiot_ret_status_t ble_timer_stop(ble_timer_t timer_id)
|
|
{
|
|
return BLE_QIOT_RS_OK;
|
|
}
|
|
|
|
ble_qiot_ret_status_t ble_timer_delete(ble_timer_t timer_id)
|
|
{
|
|
return BLE_QIOT_RS_OK;
|
|
}
|
|
|
|
// should return ATT_MTU - 3
|
|
uint16_t ble_get_user_data_mtu_size(void)
|
|
{
|
|
// this is an example, the default mtu is 23, user should get real mtu and return it
|
|
int mtu = 23;
|
|
|
|
return mtu - 3;
|
|
}
|