void main(void)
{
struct device *ipm;
int rc;
uint32_t value32;
rc = bt_enable(bt_ready);
if (rc) {
printk("Bluetooth init failed (err %d)\n", rc);
return;
}
bt_conn_cb_register(&conn_callbacks);
bt_conn_auth_cb_register(&auth_cb_display);
ipm = device_get_binding("power_ipm");
ipm_register_callback(ipm, sensor_ipm_callback, NULL);
ipm_set_enabled(ipm, 1);
while (1) {
if (default_conn) {
value32 = sys_cpu_to_le32(consumption_value);
bt_gatt_notify(default_conn, &attrs[2], &value32,
sizeof(value32));
k_sleep(INTERVAL);
value32 = sys_cpu_to_le32(solar_value);
bt_gatt_notify(default_conn, &attrs[6], &value32,
sizeof(value32));
}
k_sleep(INTERVAL);
}
}
static inline void encode_hdr(struct bt_monitor_hdr *hdr, u16_t opcode,
u16_t len)
{
struct bt_monitor_ts32 *ts;
hdr->opcode = sys_cpu_to_le16(opcode);
hdr->flags = 0;
ts = (void *)hdr->ext;
ts->type = BT_MONITOR_TS32;
ts->ts32 = sys_cpu_to_le32(k_uptime_get() * 10);
hdr->hdr_len = sizeof(*ts);
encode_drops(hdr, BT_MONITOR_COMMAND_DROPS, &drops.cmd);
encode_drops(hdr, BT_MONITOR_EVENT_DROPS, &drops.evt);
encode_drops(hdr, BT_MONITOR_ACL_TX_DROPS, &drops.acl_tx);
encode_drops(hdr, BT_MONITOR_ACL_RX_DROPS, &drops.acl_rx);
#if defined(CONFIG_BT_BREDR)
encode_drops(hdr, BT_MONITOR_SCO_TX_DROPS, &drops.sco_tx);
encode_drops(hdr, BT_MONITOR_SCO_RX_DROPS, &drops.sco_rx);
#endif
encode_drops(hdr, BT_MONITOR_OTHER_DROPS, &drops.other);
hdr->data_len = sys_cpu_to_le16(4 + hdr->hdr_len + len);
}
static void set_discoverable(uint8_t *data, uint16_t len)
{
const struct gap_set_discoverable_cmd *cmd = (void *) data;
struct gap_set_discoverable_rp rp;
switch (cmd->discoverable) {
case GAP_NON_DISCOVERABLE:
ad_flags &= ~(BT_LE_AD_GENERAL | BT_LE_AD_LIMITED);
atomic_clear_bit(¤t_settings, GAP_SETTINGS_DISCOVERABLE);
break;
case GAP_GENERAL_DISCOVERABLE:
ad_flags &= ~BT_LE_AD_LIMITED;
ad_flags |= BT_LE_AD_GENERAL;
atomic_set_bit(¤t_settings, GAP_SETTINGS_DISCOVERABLE);
break;
case GAP_LIMITED_DISCOVERABLE:
ad_flags &= ~BT_LE_AD_GENERAL;
ad_flags |= BT_LE_AD_LIMITED;
atomic_set_bit(¤t_settings, GAP_SETTINGS_DISCOVERABLE);
break;
default:
tester_rsp(BTP_SERVICE_ID_GAP, GAP_SET_DISCOVERABLE,
CONTROLLER_INDEX, BTP_STATUS_FAILED);
return;
}
rp.current_settings = sys_cpu_to_le32(current_settings);
tester_send(BTP_SERVICE_ID_GAP, GAP_SET_DISCOVERABLE, CONTROLLER_INDEX,
(uint8_t *) &rp, sizeof(rp));
}
static
u8_t *generate_aux_security_hdr(struct ieee802154_security_ctx *sec_ctx,
u8_t *p_buf)
{
struct ieee802154_aux_security_hdr *aux_sec;
if (sec_ctx->level == IEEE802154_SECURITY_LEVEL_NONE) {
return p_buf;
}
if (sec_ctx->key_mode != IEEE802154_KEY_ID_MODE_IMPLICIT) {
/* ToDo: it supports implicit mode only, for now */
return NULL;
}
aux_sec = (struct ieee802154_aux_security_hdr *)p_buf;
aux_sec->control.security_level = sec_ctx->level;
aux_sec->control.key_id_mode = sec_ctx->key_mode;
aux_sec->control.reserved = 0;
aux_sec->frame_counter = sys_cpu_to_le32(sec_ctx->frame_counter);
return p_buf + IEEE802154_SECURITY_CF_LENGTH +
IEEE802154_SECURITY_FRAME_COUNTER_LENGTH;
}
static ssize_t read_u32(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
const uint32_t *u32 = attr->user_data;
uint32_t value = sys_cpu_to_le32(*u32);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &value,
sizeof(value));
}
static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
{
struct gap_passkey_display_ev ev;
const bt_addr_le_t *addr = bt_conn_get_dst(conn);
memcpy(ev.address, addr->a.val, sizeof(ev.address));
ev.address_type = addr->type;
ev.passkey = sys_cpu_to_le32(passkey);
tester_send(BTP_SERVICE_ID_GAP, GAP_EV_PASSKEY_DISPLAY,
CONTROLLER_INDEX, (uint8_t *) &ev, sizeof(ev));
}
static void controller_info(uint8_t *data, uint16_t len)
{
struct gap_read_controller_info_rp rp;
uint32_t supported_settings;
memset(&rp, 0, sizeof(rp));
memcpy(rp.address, CONTROLLER_ADDR, sizeof(bt_addr_t));
supported_settings = BIT(GAP_SETTINGS_POWERED);
supported_settings |= BIT(GAP_SETTINGS_CONNECTABLE);
supported_settings |= BIT(GAP_SETTINGS_BONDABLE);
supported_settings |= BIT(GAP_SETTINGS_LE);
supported_settings |= BIT(GAP_SETTINGS_ADVERTISING);
rp.supported_settings = sys_cpu_to_le32(supported_settings);
rp.current_settings = sys_cpu_to_le32(current_settings);
memcpy(rp.name, CONTROLLER_NAME, sizeof(CONTROLLER_NAME));
tester_send(BTP_SERVICE_ID_GAP, GAP_READ_CONTROLLER_INFO,
CONTROLLER_INDEX, (uint8_t *) &rp, sizeof(rp));
}
static void start_advertising(const uint8_t *data, uint16_t len)
{
const struct gap_start_advertising_cmd *cmd = (void *) data;
struct gap_start_advertising_rp rp;
uint8_t adv_len, sd_len;
bool adv_conn;
int i;
for (i = 0, adv_len = 1; i < cmd->adv_data_len; adv_len++) {
if (adv_len >= ARRAY_SIZE(ad)) {
BTTESTER_DBG("ad[] Out of memory");
goto fail;
}
ad[adv_len].type = cmd->adv_data[i++];
ad[adv_len].data_len = cmd->adv_data[i++];
ad[adv_len].data = &cmd->adv_data[i];
i += ad[adv_len].data_len;
}
for (i = 0, sd_len = 0; i < cmd->scan_rsp_len; sd_len++) {
if (sd_len >= ARRAY_SIZE(sd)) {
BTTESTER_DBG("sd[] Out of memory");
goto fail;
}
sd[sd_len].type = cmd->scan_rsp[i++];
sd[sd_len].data_len = cmd->scan_rsp[i++];
sd[sd_len].data = &cmd->scan_rsp[i];
i += sd[sd_len].data_len;
}
adv_conn = atomic_test_bit(¤t_settings, GAP_SETTINGS_CONNECTABLE);
/* BTP API don't allow to set empty scan response data. */
if (bt_le_adv_start(adv_conn ? BT_LE_ADV_CONN : BT_LE_ADV_NCONN,
ad, adv_len, sd_len ? sd : NULL, sd_len) < 0) {
BTTESTER_DBG("Failed to start advertising");
goto fail;
}
atomic_set_bit(¤t_settings, GAP_SETTINGS_ADVERTISING);
rp.current_settings = sys_cpu_to_le32(current_settings);
tester_send(BTP_SERVICE_ID_GAP, GAP_START_ADVERTISING, CONTROLLER_INDEX,
(uint8_t *) &rp, sizeof(rp));
return;
fail:
tester_rsp(BTP_SERVICE_ID_GAP, GAP_START_ADVERTISING, CONTROLLER_INDEX,
BTP_STATUS_FAILED);
}
static inline void encode_hdr(struct bt_monitor_hdr *hdr, uint16_t opcode,
uint16_t len)
{
uint32_t ts32;
hdr->hdr_len = sizeof(hdr->type) + sizeof(hdr->ts32);
hdr->data_len = sys_cpu_to_le16(4 + hdr->hdr_len + len);
hdr->opcode = sys_cpu_to_le16(opcode);
hdr->flags = 0;
/* Extended header */
hdr->type = BT_MONITOR_TS32;
ts32 = k_uptime_get() * 10;
hdr->ts32 = sys_cpu_to_le32(ts32);
}
static void stop_advertising(const uint8_t *data, uint16_t len)
{
struct gap_stop_advertising_rp rp;
if (bt_le_adv_stop() < 0) {
tester_rsp(BTP_SERVICE_ID_GAP, GAP_STOP_ADVERTISING,
CONTROLLER_INDEX, BTP_STATUS_FAILED);
return;
}
atomic_clear_bit(¤t_settings, GAP_SETTINGS_ADVERTISING);
rp.current_settings = sys_cpu_to_le32(current_settings);
tester_send(BTP_SERVICE_ID_GAP, GAP_STOP_ADVERTISING, CONTROLLER_INDEX,
(uint8_t *) &rp, sizeof(rp));
}
static void set_connectable(uint8_t *data, uint16_t len)
{
const struct gap_set_connectable_cmd *cmd = (void *) data;
struct gap_set_connectable_rp rp;
if (cmd->connectable) {
atomic_set_bit(¤t_settings, GAP_SETTINGS_CONNECTABLE);
} else {
atomic_clear_bit(¤t_settings, GAP_SETTINGS_CONNECTABLE);
}
rp.current_settings = sys_cpu_to_le32(current_settings);
tester_send(BTP_SERVICE_ID_GAP, GAP_SET_CONNECTABLE, CONTROLLER_INDEX,
(uint8_t *) &rp, sizeof(rp));
}
static int ssp_passkey_reply(struct bt_conn *conn, unsigned int passkey)
{
struct bt_hci_cp_user_passkey_reply *cp;
struct net_buf *buf;
BT_DBG("");
buf = bt_hci_cmd_create(BT_HCI_OP_USER_PASSKEY_REPLY, sizeof(*cp));
if (!buf) {
return -ENOBUFS;
}
cp = net_buf_add(buf, sizeof(*cp));
bt_addr_copy(&cp->bdaddr, &conn->br.dst);
cp->passkey = sys_cpu_to_le32(passkey);
return bt_hci_cmd_send_sync(BT_HCI_OP_USER_PASSKEY_REPLY, buf, NULL);
}
static void start_advertising(const uint8_t *data, uint16_t len)
{
const struct gap_start_advertising_cmd *cmd = (void *) data;
struct gap_start_advertising_rp rp;
uint8_t adv_type, adv_len;
int i;
if (atomic_test_bit(¤t_settings, GAP_SETTINGS_CONNECTABLE)) {
adv_type = BT_LE_ADV_IND;
} else {
adv_type = BT_LE_ADV_NONCONN_IND;
}
for (i = 0, adv_len = 1; i < cmd->adv_data_len; adv_len++) {
if (adv_len >= ARRAY_SIZE(ad)) {
BTTESTER_DBG("ad[] Out of memory");
goto fail;
}
ad[adv_len].type = cmd->adv_data[i++];
ad[adv_len].data_len = cmd->adv_data[i++];
ad[adv_len].data = &cmd->adv_data[i];
i += ad[adv_len].data_len;
}
if (bt_le_adv_start(BT_LE_ADV(adv_type), ad, adv_len, NULL, 0) < 0) {
BTTESTER_DBG("Failed to start advertising");
goto fail;
}
atomic_set_bit(¤t_settings, GAP_SETTINGS_ADVERTISING);
rp.current_settings = sys_cpu_to_le32(current_settings);
tester_send(BTP_SERVICE_ID_GAP, GAP_START_ADVERTISING, CONTROLLER_INDEX,
(uint8_t *) &rp, sizeof(rp));
return;
fail:
tester_rsp(BTP_SERVICE_ID_GAP, GAP_START_ADVERTISING, CONTROLLER_INDEX,
BTP_STATUS_FAILED);
}
void main(void)
{
struct device *ipm;
int rc;
uint16_t value16;
uint32_t value32;
rc = bt_enable(bt_ready);
if (rc) {
printk("Bluetooth init failed (err %d)\n", rc);
return;
}
bt_conn_cb_register(&conn_callbacks);
bt_conn_auth_cb_register(&auth_cb_display);
ipm = device_get_binding("ess_ipm");
ipm_register_callback(ipm, sensor_ipm_callback, NULL);
ipm_set_enabled(ipm, 1);
while (1) {
/* Notify value changes via BLE here so that the notification intervals can be controlled. */
if (default_conn) {
value16 = sys_cpu_to_le16(temp_value);
bt_gatt_notify(default_conn, &attrs[2], &value16, sizeof(value16));
k_sleep(INTERVAL);
value16 = sys_cpu_to_le16(humidity_value);
bt_gatt_notify(default_conn, &attrs[6], &value16, sizeof(value16));
k_sleep(INTERVAL);
value32 = sys_cpu_to_le32(pressure_value);
bt_gatt_notify(default_conn, &attrs[10], &value32, sizeof(value32));
k_sleep(INTERVAL);
value16 = sys_cpu_to_le16(uv_index_value);
bt_gatt_notify(default_conn, &attrs[14], &uv_index_value, sizeof(uv_index_value));
}
k_sleep(INTERVAL);
}
}
static void measurement_nfy(struct bt_conn *conn, uint32_t cwr, uint16_t lwet,
uint16_t ccr, uint16_t lcet)
{
struct csc_measurement_nfy *nfy;
uint8_t buf[sizeof(*nfy) +
(cwr ? sizeof(struct wheel_rev_data_nfy) : 0) +
(ccr ? sizeof(struct crank_rev_data_nfy) : 0)];
uint16_t len = 0;
nfy = (void *) buf;
nfy->flags = 0;
/* Send Wheel Revolution data is present */
if (cwr) {
struct wheel_rev_data_nfy data;
nfy->flags |= CSC_WHEEL_REV_DATA_PRESENT;
data.cwr = sys_cpu_to_le32(cwr);
data.lwet = sys_cpu_to_le16(lwet);
memcpy(nfy->data, &data, sizeof(data));
len += sizeof(data);
}
/* Send Crank Revolution data is present */
if (ccr) {
struct crank_rev_data_nfy data;
nfy->flags |= CSC_CRANK_REV_DATA_PRESENT;
data.ccr = sys_cpu_to_le16(ccr);
data.lcet = sys_cpu_to_le16(lcet);
memcpy(nfy->data + len, &data, sizeof(data));
}
bt_gatt_notify(NULL, &csc_attrs[2], buf, sizeof(buf));
}
