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);
}
}
bool BLECharacteristicImp::writeValue(const byte value[], int length, int offset)
{
int status;
bool retVal = false;
_setValue(value, length, offset);
// Address same is GATT server. Send notification if CCCD enabled
// Different is GATT client. Send write request
if (true == BLEUtils::isLocalBLE(_ble_device) &&
NULL != _attr_chrc_value)
{
// Notify for peripheral.
status = bt_gatt_notify(NULL, _attr_chrc_value, value, length, NULL);
// Sid. KW found status is always 0.
// if (!status)
// {
retVal = true;
// }
}
//Not schedule write request for central
// The write request may failed.
// If user want to get latest set value. Call read and get the real value
return retVal;
}
int ble_hrs_update(uint8_t value)
{
struct ble_hrs_measurement measurement;
measurement.flags = 0;
measurement.value = value;
return bt_gatt_notify(NULL, hrs_value, &measurement,
sizeof(measurement), NULL);
}
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);
}
}
void bas_notify(void)
{
if (!simulate_blvl) {
return;
}
battery--;
if (!battery) {
/* Software eco battery charger */
battery = 100;
}
bt_gatt_notify(NULL, &attrs[2], &battery, sizeof(battery));
}
void temperature_ipm_callback(void *context, uint32_t id, volatile void *data)
{
struct bt_conn *conn = (struct bt_conn *) context;
switch(id) {
case 1:
temperature = *(int32_t*) data;
printk("Got temperature from ARC %d\n", temperature);
bt_gatt_notify(conn, &attrs[2], &temperature, sizeof(temperature));
break;
case 2:
humidity = *(uint32_t*) data;
printk("Got humidity from ARC %d\n", humidity);
break;
}
}
static void ctrl_point_ind(struct bt_conn *conn, uint8_t req_op, uint8_t status,
const void *data, uint16_t data_len)
{
struct sc_ctrl_point_ind *ind;
uint8_t buf[sizeof(*ind) + data_len];
ind = (void *) buf;
ind->op = SC_CP_OP_RESPONSE;
ind->req_op = req_op;
ind->status = status;
/* Send data (supported locations) if present */
if (data && data_len) {
memcpy(ind->data, data, data_len);
}
bt_gatt_notify(conn, &csc_attrs[9], buf, sizeof(buf));
}
bool
BLECharacteristic::setValue(const unsigned char value[], uint16_t length)
{
int status;
_setValue(value, length);
if (_attr_chrc_value)
{
// TODO: Notify for peripheral.
// Write request for central.
status = bt_gatt_notify(NULL, _attr_chrc_value, value, length, NULL);
if (0 != status)
{
return false;
}
}
return true;
}
static int bas_update_bat_level(struct bt_conn *conn, uint16_t char_handle,
uint16_t len, uint8_t *p_data,
struct ble_update_data_rsp *p_rsp)
{
struct _bt_gatt_ccc *ccc = bas_attrs[BLVL_CCC_HANDLE_IDX].user_data;
/* use CCCD value for ble service specific purpose to save ram.
* notif & indication use the 2 LSBs. */
if ((ccc->value & (BLE_SVC_BAS_NOTIF_SUP_ON | BT_GATT_CCC_NOTIFY)) ==
(BLE_SVC_BAS_NOTIF_SUP_ON | BT_GATT_CCC_NOTIFY)) {
cli_rsp = p_rsp;
bt_gatt_notify(conn, char_handle, (const void *)p_data,
len, bat_lvl_notified);
} else {
struct ble_gatts_set_attribute_params params;
params.value_handle = char_handle;
params.offset = 0;
ble_gatts_set_attribute_value_req(¶ms, p_data, len, p_rsp);
}
return BLE_STATUS_SUCCESS;
}
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));
}
void main(void)
#endif
{
int err;
err = bt_enable(bt_ready);
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return;
}
bt_conn_cb_register(&conn_callbacks);
while (1) {
task_sleep(sys_clock_ticks_per_sec);
/* CSC simulation */
if (csc_simulate) {
csc_simulation();
}
/* Battery level simulation */
if (bas_simulate) {
blvl -= 1;
if (!blvl) {
/* Software eco battery charger */
blvl = 100;
}
bt_gatt_notify(NULL, &bas_attrs[2], &blvl,
sizeof(blvl));
}
}
}
