uint32_t ble_bas_init(ble_bas_t * p_bas, const ble_bas_init_t * p_bas_init) { if (p_bas == NULL || p_bas_init == NULL) { return NRF_ERROR_NULL; } uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure p_bas->evt_handler = p_bas_init->evt_handler; p_bas->conn_handle = BLE_CONN_HANDLE_INVALID; p_bas->is_notification_supported = p_bas_init->support_notification; p_bas->battery_level_last = INVALID_BATTERY_LEVEL; // Add service BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_BATTERY_SERVICE); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_bas->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add battery level characteristic return battery_level_char_add(p_bas, p_bas_init); }
uint32_t initBlePHYSEN(ble_pss_t * p_pss, const ble_pss_init_t * p_pss_init) { /// init BLE physical sensor service uint32_t err_code; ble_uuid_t ble_uuid; // initialize service structure p_pss->evt_handler = p_pss_init->evt_handler; p_pss->conn_handle = BLE_CONN_HANDLE_INVALID; p_pss->is_notification_supported = p_pss_init->support_notification; // add service ble_uuid128_t base_uuid= {PHY_SENSOR_UUID_BASE}; err_code = sd_ble_uuid_vs_add(&base_uuid, &p_pss->uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = p_pss->uuid_type; ble_uuid.uuid = BLE_UUID_PHY_SENSOR_SERVICE; err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_pss->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add physics sensor characteristic return addCharPHYSEN(p_pss, p_pss_init); }
uint32_t ble_qodome_init(void) { uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure ble_qodome_t * p_qodome = &m_qodome; p_qodome->conn_handle = BLE_CONN_HANDLE_INVALID; // Add service BLE_UUID_BLE_ASSIGN(ble_uuid, QODOME_PUBLIC_SERVICE); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_qodome->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add memory dump characteristic err_code = hts_qodome_char_add(p_qodome); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }
void cch_service_init(ble_cch_t * p_cch_service) { uint32_t err_code; // Variable to hold return codes from library and softdevice functions //Declare 16-bit service and 128-bit base UUIDs and add them to the BLE stack ble_uuid_t service_uuid; ble_uuid128_t base_uuid = BLE_UUID_CCH_BASE_UUID; service_uuid.uuid = BLE_UUID_CCH_SERVICE_UUID; err_code = sd_ble_uuid_vs_add(&base_uuid, &service_uuid.type); APP_ERROR_CHECK(err_code); // Set our service connection handle to default value. I.e. an invalid handle since we are not yet in a connection. p_cch_service->conn_handle = BLE_CONN_HANDLE_INVALID; // Add our service err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &service_uuid, &p_cch_service->service_handle); APP_ERROR_CHECK(err_code); // Call the function our_char_add() to add our new characteristic to the service. cch_char_add(p_cch_service); }
/***************************************************************************** * Interface functions *****************************************************************************/ uint32_t mesh_gatt_init(uint32_t access_address, uint8_t channel, uint32_t interval_min_ms) { uint32_t error_code; mesh_metadata_char_t md_char; md_char.mesh_access_addr = access_address; md_char.mesh_interval_min_ms = interval_min_ms; md_char.mesh_channel = channel; ble_uuid_t ble_srv_uuid; ble_srv_uuid.type = BLE_UUID_TYPE_BLE; ble_srv_uuid.uuid = MESH_SRV_UUID; error_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_srv_uuid, &m_mesh_service.service_handle); if (error_code != NRF_SUCCESS) { return NRF_ERROR_INTERNAL; } error_code = sd_ble_uuid_vs_add(&m_mesh_base_uuid, &m_mesh_base_uuid_type); if (error_code != NRF_SUCCESS) { return error_code; } error_code = mesh_md_char_add(&md_char); if (error_code != NRF_SUCCESS) { return error_code; } error_code = mesh_value_char_add(); if (error_code != NRF_SUCCESS) { return error_code; } return NRF_SUCCESS; }
uint32_t ble_bps_init(ble_bps_t * p_bps, const ble_bps_init_t * p_bps_init) { uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure p_bps->evt_handler = p_bps_init->evt_handler; p_bps->conn_handle = BLE_CONN_HANDLE_INVALID; p_bps->feature = p_bps_init->feature; // Add service BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_BLOOD_PRESSURE_SERVICE); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_bps->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add measurement characteristic err_code = bps_measurement_char_add(p_bps, p_bps_init); if (err_code != NRF_SUCCESS) { return err_code; } // Add feature characteristic err_code = bps_feature_char_add(p_bps, p_bps_init); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }
uint32_t ble_lbs_init(ble_lbs_t * p_lbs, const ble_lbs_init_t * p_lbs_init) { uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure. p_lbs->conn_handle = BLE_CONN_HANDLE_INVALID; p_lbs->led_write_handler = p_lbs_init->led_write_handler; // Add service. ble_uuid128_t base_uuid = {LBS_UUID_BASE}; err_code = sd_ble_uuid_vs_add(&base_uuid, &p_lbs->uuid_type); VERIFY_SUCCESS(err_code); ble_uuid.type = p_lbs->uuid_type; ble_uuid.uuid = LBS_UUID_SERVICE; err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_lbs->service_handle); VERIFY_SUCCESS(err_code); // Add characteristics. err_code = button_char_add(p_lbs, p_lbs_init); VERIFY_SUCCESS(err_code); err_code = led_char_add(p_lbs, p_lbs_init); VERIFY_SUCCESS(err_code); return NRF_SUCCESS; }
uint32_t ble_achs_init(ble_achs_t * p_achs, const ble_achs_init_t * p_achs_init) { VERIFY_NOT_NULL_PARAM(p_achs); VERIFY_NOT_NULL_PARAM(p_achs_init); uint32_t err_code; ble_uuid_t service_uuid; // Invalidate any previous existing connection handle. p_achs->conn_handle = BLE_CONN_HANDLE_INVALID; service_uuid.uuid = LOCAL_SERVICE_UUID; err_code = sd_ble_uuid_vs_add(&m_base_uuid128, &service_uuid.type); if (err_code != NRF_SUCCESS) { return err_code; } err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &service_uuid, &m_service_handle); if (err_code != NRF_SUCCESS) { return err_code; } err_code = ach_report_char_add(service_uuid.type); if (err_code == NRF_SUCCESS) { m_module_initialized = true; } return err_code; }
uint32_t ble_acc_init(ble_acc_t * p_acc, const ble_acc_init_t * p_acc_init) { uint32_t err_code; ble_uuid_t ble_uuid; ble_uuid128_t acc_acce_uuid = {{0xAA, 0xCA, 0x55, 0xAC, 0xEE, 0xEF, 0xFE, 0xDE, 0xEE, 0xAF, 0xBE, 0xA0, 0x00, 0x00, 0xA0, 0xEF}}; //nb bytes 12 and 13 are ignored // Initialize service structure p_acc->evt_handler = p_acc_init->evt_handler; p_acc->conn_handle = BLE_CONN_HANDLE_INVALID; p_acc->is_notification_supported = p_acc_init->support_notification; p_acc->accel_level_last = INVALID_accel_LEVEL; // Add service // Add uuid to p_acc struct and add to sd stack err_code = sd_ble_uuid_vs_add(&acc_acce_uuid, &p_acc->uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = p_acc->uuid_type; ble_uuid.uuid = BLE_UUID_TYPE_VENDOR_BEGIN; err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_acc->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add accel level characteristic return accel_level_char_add(p_acc, p_acc_init); }
uint32_t conn_mw_ble_gatts_service_add(uint8_t const * const p_rx_buf, uint32_t rx_buf_len, uint8_t * const p_tx_buf, uint32_t * const p_tx_buf_len) { SER_ASSERT_NOT_NULL(p_rx_buf); SER_ASSERT_NOT_NULL(p_tx_buf); SER_ASSERT_NOT_NULL(p_tx_buf_len); uint8_t type; ble_uuid_t uuid = {0}; ble_uuid_t * p_uuid = &uuid; uint16_t handle; uint16_t * p_handle = &handle; uint32_t err_code = NRF_SUCCESS; uint32_t sd_err_code; err_code = ble_gatts_service_add_req_dec(p_rx_buf, rx_buf_len, &type, &p_uuid, &p_handle); SER_ASSERT(err_code == NRF_SUCCESS, err_code); sd_err_code = sd_ble_gatts_service_add(type, p_uuid, p_handle); err_code = ble_gatts_service_add_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len, p_handle); SER_ASSERT(err_code == NRF_SUCCESS, err_code); return err_code; }
// Function for initializing the Light Control Service uint32_t ble_lc_init(ble_lc_t * p_lc, const ble_lc_init_t * p_lc_init, ble_uuid_t * ble_uuid_service, ble_uuid_t * ble_uuid_char_status, ble_uuid_t * ble_uuid_char_cmd) { uint32_t err_code; // Initialize service structure p_lc->conn_handle = BLE_CONN_HANDLE_INVALID; p_lc->data_handler_cmd = p_lc_init->data_handler_cmd; p_lc->data_handler_status = p_lc_init->data_handler_status; p_lc->is_notification_enabled = false; // Add the Light Control service err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, ble_uuid_service, &p_lc->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add the Light Status characteristic err_code = light_status_char_add(p_lc, p_lc_init, ble_uuid_char_status); if (err_code != NRF_SUCCESS) { return err_code; } // Add the Light Command characteristic err_code = light_cmd_char_add(p_lc, p_lc_init, ble_uuid_char_cmd); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }
uint32_t ble_blinkys_init(ble_blinkys_t * p_blinkys, const ble_blinkys_init_t * p_blinkys_init) { uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure p_blinkys->conn_handle = BLE_CONN_HANDLE_INVALID; p_blinkys->write_handler = p_blinkys_init->write_handler; // Add base UUID to softdevice's internal list. ble_uuid128_t base_uuid = {BLINKY_UUID_BASE}; err_code = sd_ble_uuid_vs_add(&base_uuid, &p_blinkys->uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = p_blinkys->uuid_type; ble_uuid.uuid = BLINKY_UUID_SERVICE; err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_blinkys->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } err_code = blinky_char_add(p_blinkys, p_blinkys_init); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }
uint32_t ble_rcmon_init(ble_rcmon_t * p_rcmon, const ble_rcmon_init_t * p_rcmon_init) { app_trace_log("\r\nrcmon_init\r\n"); uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure. p_rcmon->conn_handle = BLE_CONN_HANDLE_INVALID; // Add service. ble_uuid128_t base_uuid = {RCMON_UUID_BASE}; err_code = sd_ble_uuid_vs_add(&base_uuid, &p_rcmon->uuid_type); APP_ERROR_CHECK(err_code); ble_uuid.type = p_rcmon->uuid_type; ble_uuid.uuid = RCMON_UUID_SERVICE; err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_rcmon->service_handle); APP_ERROR_CHECK(err_code); p_rcmon_init->pdata->accelerometer[0] = 1000; p_rcmon_init->pdata->accelerometer[1] = 2000; p_rcmon_init->pdata->accelerometer[2] = 3000; // Add characteristics. err_code = data_char_add(p_rcmon, p_rcmon_init); APP_ERROR_CHECK(err_code); err_code = config_char_add(p_rcmon, p_rcmon_init); APP_ERROR_CHECK(err_code); app_trace_log("added chars\r\n"); return NRF_SUCCESS; }
uint32_t ble_ias_init(ble_ias_t * p_ias, const ble_ias_init_t * p_ias_init) { uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure if (p_ias_init->evt_handler == NULL) { return NRF_ERROR_INVALID_PARAM; } p_ias->evt_handler = p_ias_init->evt_handler; // Add service BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_IMMEDIATE_ALERT_SERVICE); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_ias->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add alert level characteristic return alert_level_char_add(p_ias); }
void service_doorlock_init(void) { uint32_t err_code; ble_uuid_t ble_uuid; ble_doorlock_t *p_doorlock = &m_doorlock; ble_doorlock_init_t *p_doorlock_init = &m_doorlock_init; m_doorlock_init.lock_control_handler = lock_control_handler; // Initialize service structure p_doorlock->conn_handle = BLE_CONN_HANDLE_INVALID; p_doorlock->lock_control_handler = p_doorlock_init->lock_control_handler; // Add service ble_uuid128_t base_uuid = {DOORLOCK_UUID_BASE}; err_code = sd_ble_uuid_vs_add(&base_uuid, &p_doorlock->uuid_type); APP_ERROR_CHECK(err_code); ble_uuid.type = p_doorlock->uuid_type; ble_uuid.uuid = DOORLOCK_UUID_SERVICE; err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_doorlock->service_handle); APP_ERROR_CHECK(err_code); err_code = lock_char_add(p_doorlock, p_doorlock_init); APP_ERROR_CHECK(err_code); }
uint32_t ble_cscs_init(ble_cscs_t * p_cscs, const ble_cscs_init_t * p_cscs_init) { uint32_t err_code; ble_uuid_t ble_uuid; ble_cs_ctrlpt_init_t sc_ctrlpt_init; // Initialize service structure p_cscs->evt_handler = p_cscs_init->evt_handler; p_cscs->conn_handle = BLE_CONN_HANDLE_INVALID; p_cscs->feature = p_cscs_init->feature; // Add service BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_CYCLING_SPEED_AND_CADENCE); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_cscs->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add cycling speed and cadence measurement characteristic err_code = csc_measurement_char_add(p_cscs, p_cscs_init); if (err_code != NRF_SUCCESS) { return err_code; } // Add cycling speed and cadence feature characteristic err_code = csc_feature_char_add(p_cscs, p_cscs_init); if (err_code != NRF_SUCCESS) { return err_code; } // Add Sensor Location characteristic (optional) if (p_cscs_init->sensor_location != NULL) { err_code = csc_sensor_loc_char_add(p_cscs, p_cscs_init); if (err_code != NRF_SUCCESS) { return err_code; } } //Add speed and cadence control point characteristic sc_ctrlpt_init.error_handler = p_cscs_init->error_handler; sc_ctrlpt_init.size_list_supported_locations = p_cscs_init->size_list_supported_locations; sc_ctrlpt_init.supported_functions = p_cscs_init->ctrplt_supported_functions; sc_ctrlpt_init.evt_handler = p_cscs_init->ctrlpt_evt_handler; sc_ctrlpt_init.list_supported_locations = p_cscs_init->list_supported_locations; sc_ctrlpt_init.sc_ctrlpt_attr_md = p_cscs_init->csc_ctrlpt_attr_md; sc_ctrlpt_init.sensor_location_handle = p_cscs->sensor_loc_handles.value_handle; sc_ctrlpt_init.service_handle = p_cscs->service_handle; return ble_sc_ctrlpt_init(&p_cscs->ctrl_pt, &sc_ctrlpt_init); }
ble_error_t nRF51GattServer::addService(GattService &service) { /* ToDo: Make sure we don't overflow the array, etc. */ /* ToDo: Make sure this service UUID doesn't already exist (?) */ /* ToDo: Basic validation */ /* Add the service to the nRF51 */ ble_uuid_t nordicUUID; nordicUUID = custom_convert_to_nordic_uuid(service.getUUID()); uint16_t serviceHandle; // ASSERT( ERROR_NONE == //_modify // sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, // &nordicUUID, // &serviceHandle), // BLE_ERROR_PARAM_OUT_OF_RANGE ); nrf_err_check(sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &nordicUUID, &serviceHandle) ); service.setHandle(serviceHandle); /* Add characteristics to the service */ for (uint8_t i = 0; i < service.getCharacteristicCount(); i++) { GattCharacteristic *p_char = service.getCharacteristic(i); nordicUUID = custom_convert_to_nordic_uuid(p_char->getUUID()); // ASSERT ( ERROR_NONE == //_modify // custom_add_in_characteristic(service.getHandle(), // &nordicUUID, // p_char->getProperties(), // NULL, // p_char->getInitialLength(), // p_char->getMaxLength(), // &nrfCharacteristicHandles[characteristicCount]), // BLE_ERROR_PARAM_OUT_OF_RANGE ); nrf_err_check(custom_add_in_characteristic(service.getHandle(), &nordicUUID, p_char->getProperties(), NULL, p_char->getInitialLength(), p_char->getMaxLength(), &nrfCharacteristicHandles[characteristicCount])); /* Update the characteristic handle */ uint16_t charHandle = characteristicCount; p_characteristics[characteristicCount++] = p_char; p_char->setHandle(charHandle); if ((p_char->getValuePtr() != NULL) && (p_char->getInitialLength() > 0)) { updateValue(charHandle, p_char->getValuePtr(), p_char->getInitialLength(), false /* localOnly */); } } serviceCount++; return BLE_ERROR_NONE; }
/**@brief Function for decoding a command packet with RPC_SD_BLE_GATTS_SERVICE_ADD opcode. * * This function will decode the command, call the BLE Stack API, and also send command response * to the peer through the the transport layer. * * @param[in] p_command The encoded structure that needs to be decoded and passed on * to the BLE Stack API. * @param[in] command_len The length of the encoded command read from transport layer. * * @retval NRF_SUCCESS If the decoding of the command was successful, the SoftDevice * API was called, and the command response was sent to peer, * otherwise an error code. * @retval NRF_ERROR_INVALID_LENGTH If the content length of the packet is not conforming to the * codec specification. */ static uint32_t gatts_service_add_handle(const uint8_t * const p_command, uint32_t command_len) { uint8_t type; uint16_t * p_handle; uint32_t err_code; ble_uuid_t uuid; ble_uuid_t * p_uuid; uint8_t resp_data[sizeof(uint16_t)]; uint32_t index = 0; uint16_t handle = 0; type = p_command[index++]; RPC_DECODER_LENGTH_CHECK(command_len, index, SD_BLE_GATTS_SERVICE_ADD); // Service UUID field is present. if (p_command[index++] == RPC_BLE_FIELD_PRESENT) { uuid.uuid = uint16_decode(&p_command[index]); index += sizeof(uint16_t); uuid.type = p_command[index++]; p_uuid = &uuid; RPC_DECODER_LENGTH_CHECK(command_len, index, SD_BLE_GATTS_SERVICE_ADD); } else { RPC_DECODER_LENGTH_CHECK(command_len, index, SD_BLE_GATTS_SERVICE_ADD); p_uuid = NULL; } // Handle present. if (p_command[index++] == RPC_BLE_FIELD_PRESENT) { p_handle = &handle; } else { p_handle = NULL; } RPC_DECODER_LENGTH_CHECK(command_len, index, SD_BLE_GATTS_SERVICE_ADD); err_code = sd_ble_gatts_service_add(type, p_uuid, p_handle); if (err_code == NRF_SUCCESS) { UNUSED_VARIABLE(uint16_encode(handle, resp_data)); return ble_rpc_cmd_resp_data_send(SD_BLE_GATTS_SERVICE_ADD, err_code, resp_data, sizeof(resp_data)); } else { return ble_rpc_cmd_resp_send(SD_BLE_GATTS_SERVICE_ADD, err_code); } }
uint32_t ble_nus_init(ble_nus_t * p_nus, const ble_nus_init_t * p_nus_init) { uint32_t err_code; ble_uuid_t ble_uuid; ble_uuid128_t nus_base_uuid = {{0x9E, 0xCA, 0xDC, 0x24, 0x0E, 0xE5, 0xA9, 0xE0, 0x93, 0xF3, 0xA3, 0xB5, 0x00, 0x00, 0x40, 0x6E}}; if ((p_nus == NULL) || (p_nus_init == NULL)) { return NRF_ERROR_NULL; } // Initialize service structure. p_nus->conn_handle = BLE_CONN_HANDLE_INVALID; p_nus->data_handler = p_nus_init->data_handler; p_nus->is_notification_enabled = false; /**@snippet [Adding proprietary Service to S110 SoftDevice] */ // Add custom base UUID. err_code = sd_ble_uuid_vs_add(&nus_base_uuid, &p_nus->uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = p_nus->uuid_type; ble_uuid.uuid = BLE_UUID_NUS_SERVICE; // Add service. err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_nus->service_handle); /**@snippet [Adding proprietary Service to S110 SoftDevice] */ if (err_code != NRF_SUCCESS) { return err_code; } // Add RX Characteristic. err_code = rx_char_add(p_nus, p_nus_init); if (err_code != NRF_SUCCESS) { return err_code; } // Add TX Characteristic. err_code = tx_char_add(p_nus, p_nus_init); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }
uint32_t add_vendor_service(VendorService* service){ if(ble_device->vendor_service_count >= MAX_VENDOR_SERVICE_COUNT) return 1; create_uuid_for_vendor_service(&service->uuid, ble_device->vendor_service_count); uint32_t error_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &service->uuid, &service->handle); APP_ERROR_CHECK(error_code); ble_device->vendor_services[ble_device->vendor_service_count] = service; ble_device->vendor_service_count++; return 0; }
uint32_t new_server_nus_init(new_server_t * p_nus, const new_service_nus_init_t * p_nus_init) { uint32_t err_code; ble_uuid_t ble_uuid; ble_uuid128_t nus_base_uuid = NEW_SERVECE_NUS_BASE_UUID; if ((p_nus == NULL) || (p_nus_init == NULL)) { return NRF_ERROR_NULL; } // Initialize the service structure. p_nus->conn_handle = BLE_CONN_HANDLE_INVALID; p_nus->data_handler = p_nus_init->data_handler; p_nus->is_notification_enabled = false; /**@snippet [Adding proprietary Service to S110 SoftDevice] */ // Add a custom base UUID. err_code = sd_ble_uuid_vs_add(&nus_base_uuid, &p_nus->uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = p_nus->uuid_type; ble_uuid.uuid = NEW_SERVECE_NUS_SERVICE; // Add the service. err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_nus->service_handle); //#if ((DEBUG_UART_EN) && (ENABLE_BLE_DEBUG)) // DbgPrintf("service2_handle=%x\r\n",p_nus->service_handle); //#endif /**@snippet [Adding proprietary Service to S110 SoftDevice] */ if (err_code != NRF_SUCCESS) { return err_code; } // Add the TX Characteristic. err_code = new_service_tx_char_add(p_nus, p_nus_init); if (err_code != NRF_SUCCESS) { return err_code; } // Add the RX Characteristic. err_code = new_service_rx_char_add(p_nus, p_nus_init); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }
uint32_t ble_lss_init(ble_lss_t * p_lss, const ble_lss_init_t * p_lss_init) { uint32_t err_code; ble_uuid_t ble_uuid; ble_uuid128_t lss_base_uuid = LSS_BASE_UUID; if ((p_lss == NULL) || (p_lss_init == NULL)) { return NRF_ERROR_NULL; } // Initialize the service structure. p_lss->conn_handle = BLE_CONN_HANDLE_INVALID; p_lss->data_handler = p_lss_init->data_handler; p_lss->is_notification_enabled = false; /**@snippet [Adding proprietary Service to S110 SoftDevice] */ // Add a custom base UUID. err_code = sd_ble_uuid_vs_add(&lss_base_uuid, &p_lss->uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = p_lss->uuid_type; ble_uuid.uuid = BLE_UUID_LSS_SERVICE; // Add the service. err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_lss->service_handle); /**@snippet [Adding proprietary Service to S110 SoftDevice] */ if (err_code != NRF_SUCCESS) { return err_code; } // Add the RX Characteristic. err_code = rx_char_add(p_lss, p_lss_init); if (err_code != NRF_SUCCESS) { return err_code; } // Add the TX Characteristic. err_code = tx_char_add(p_lss, p_lss_init); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }
uint32_t ble_led_init(ble_led_t * p_led) { ble_uuid_t service_uuid; uint32_t ret; // check if parameters are correctly set up if (p_led == NULL) { return NRF_ERROR_NULL; } p_led->conn_handle = BLE_CONN_HANDLE_INVALID; // create a custom base BLE uuid for our service (ble_led_service in ascii) const ble_uuid128_t base_uuid128 = { { 0x62, 0x6c, 0x65, 0x5f, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x00 } }; // setup LED service uuid service_uuid.uuid = BLE_LED_SERVICE_UUID; // add our custom services in BLE stack's table ret = sd_ble_uuid_vs_add(&base_uuid128, &(service_uuid.type)); if (ret != NRF_SUCCESS) { return ret; } // sd led service declaration to the local server ATT table ret = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &service_uuid, &(p_led->service_handle)); if (ret != NRF_SUCCESS) { return ret; } p_led->uuid_type = service_uuid.type; // add LED status Characteristics ret = ble_led_sta_char_add(p_led); if (ret != NRF_SUCCESS) { return ret; } return NRF_SUCCESS; }
uint32_t ble_dfu_init(ble_dfu_t * p_dfu, ble_dfu_init_t * p_dfu_init) { if ((p_dfu == NULL) || (p_dfu_init == NULL) || (p_dfu_init->evt_handler == NULL)) { return NRF_ERROR_NULL; } p_dfu->conn_handle = BLE_CONN_HANDLE_INVALID; ble_uuid_t service_uuid; uint32_t err_code; const ble_uuid128_t base_uuid128 = { { 0x23, 0xD1, 0xBC, 0xEA, 0x5F, 0x78, 0x23, 0x15, 0xDE, 0xEF, 0x12, 0x12, 0x00, 0x00, 0x00, 0x00 } }; service_uuid.uuid = BLE_DFU_SERVICE_UUID; err_code = sd_ble_uuid_vs_add(&base_uuid128, &(service_uuid.type)); VERIFY_SUCCESS(err_code); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &service_uuid, &(p_dfu->service_handle)); VERIFY_SUCCESS(err_code); p_dfu->uuid_type = service_uuid.type; err_code = dfu_pkt_char_add(p_dfu); VERIFY_SUCCESS(err_code); err_code = dfu_ctrl_pt_add(p_dfu); VERIFY_SUCCESS(err_code); err_code = dfu_rev_char_add(p_dfu, p_dfu_init); VERIFY_SUCCESS(err_code); p_dfu->evt_handler = p_dfu_init->evt_handler; if (p_dfu_init->error_handler != NULL) { p_dfu->error_handler = p_dfu_init->error_handler; } m_is_dfu_service_initialized = true; return NRF_SUCCESS; }
void service_addService(const service_service_t* service, const service_characteristic_t characteristics[]) { uint32_t err_code; uint16_t service_handle; err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &service->uuid, &service_handle); APP_ERROR_CHECK(err_code); for (unsigned i = 0; characteristics[i].name; i++) { if (service_state.mapfree >= HOMEKIT_CONFIG_SERVICE_MAX_CHARACTERISTICS) { APP_ERROR_CHECK(NRF_ERROR_INTERNAL); } ble_gatts_attr_md_t metadata = { .read_perm = { !!characteristics[i].read, !!characteristics[i].read }, .write_perm = { !!characteristics[i].write, !!characteristics[i].write }, .rd_auth = !!characteristics[i].read, .wr_auth = !!characteristics[i].write, .vlen = 1, .vloc = BLE_GATTS_VLOC_USER }; const ble_gatts_attr_t attr = { .p_uuid = (ble_uuid_t*)&characteristics[i].uuid, .p_attr_md = &metadata, .max_len = SESSION_CIPHER_BUFFERLEN(characteristics[i].max_length ? characteristics[i].max_length : characteristics[i].length), .p_value = buffer_buffer }; const ble_gatts_char_md_t character = { .char_props = { .read = !!characteristics[i].read, .write = !!characteristics[i].write, .notify = characteristics[i].notify }, .p_char_user_desc = (uint8_t*)characteristics[i].name, .char_user_desc_max_size = strlen(characteristics[i].name), .char_user_desc_size = strlen(characteristics[i].name) }; ble_gatts_char_handles_t newhandle; err_code = sd_ble_gatts_characteristic_add(service_handle, &character, &attr, &newhandle); APP_ERROR_CHECK(err_code); service_state.map[service_state.mapfree].handle = newhandle.value_handle; service_state.map[service_state.mapfree].characteristic = &characteristics[i]; service_state.mapfree++; } }
/**@brief Function for adding the Service. * * @details This function adds the service and the characteristic within it to the local db. * */ static void service_add(void) { ble_uuid_t service_uuid; uint32_t err_code; service_uuid.uuid = LOCAL_SERVICE_UUID; err_code = sd_ble_uuid_vs_add(&m_base_uuid128, &service_uuid.type); APP_ERROR_CHECK(err_code); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &service_uuid, &m_service_handle); APP_ERROR_CHECK(err_code); // Add characteristics char_add(service_uuid.type); }
uint32_t ble_tps_init(ble_tps_t * p_tps, const ble_tps_init_t * p_tps_init) { uint32_t err_code; ble_uuid_t ble_uuid; // Add service BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_TX_POWER_SERVICE); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_tps->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add TX Power Level characteristic return tx_power_level_char_add(p_tps, p_tps_init); }
uint32_t ble_iqo_init(ble_iqo_t * p_iqo) { uint32_t err_code; ble_uuid_t ble_uuid; iqo_ptr = p_iqo; // Initialize service structure p_iqo->conn_handle = BLE_CONN_HANDLE_INVALID; // Add service BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_IQO_SERVICE); err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_iqo->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add memory dump characteristic err_code = iqo_cmd_char_add(p_iqo); if (err_code != NRF_SUCCESS) { return err_code; } err_code = iqo_identify_char_add(p_iqo); if (err_code != NRF_SUCCESS) { return err_code; } err_code = iqo_wifi_status_char_add(p_iqo); if (err_code != NRF_SUCCESS) { return err_code; } err_code = iqo_peer_status_char_add(p_iqo); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }
uint32_t ble_si7021_init(ble_si7021_t * p_si7021, const ble_si7021_init_t * p_si7021_init) { uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure. p_si7021->conn_handle = BLE_CONN_HANDLE_INVALID; p_si7021->evt_handler = p_si7021_init->evt_handler; p_si7021->last_humraw = 0; p_si7021->last_tempraw = 0; p_si7021->running = 0; p_si7021->interval = 1000; // i.e. 1000ms // Add a Vendor Specific UUID 128-Bit ble_uuid128_t base_uuid = {BLE_si7021_UUID_BASE}; err_code = sd_ble_uuid_vs_add(&base_uuid, &p_si7021->uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = p_si7021->uuid_type; ble_uuid.uuid = BLE_si7021_UUID_SERVICE; // Add a service declaration to the Attribute Table err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_si7021->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } NRF_LOG_DEBUG("sd_ble_gatts_service_add %x,%x\n\r",p_si7021->conn_handle,p_si7021->value_char_handles.value_handle); // err_code = ble_si7021_com_char_add(p_si7021, p_si7021_init); if (err_code != NRF_SUCCESS) { return err_code; } NRF_LOG_DEBUG("ble_si7021_com_char_add %x,%x\n\r",p_si7021->conn_handle,p_si7021->com_char_handles.value_handle); // err_code = ble_si7021_value_char_add(p_si7021, p_si7021_init); if (err_code != NRF_SUCCESS) { return err_code; } NRF_LOG_DEBUG("ble_si7021_value_char_add %x,%x\n\r",p_si7021->conn_handle,p_si7021->value_char_handles.value_handle); return NRF_SUCCESS; }
/* * Function for initializing Temp's BLE usage. */ uint32_t ble_temp_init(ble_temp_t * p_temp) { uint32_t err_code; ble_uuid_t ble_uuid; // Initialize Temperature Measurement Interval timer err_code = app_timer_create(&m_temperature_timer_id, APP_TIMER_MODE_REPEATED, temperature_timeout_handler); APP_ERROR_CHECK(err_code); // Convert default Interval value to ticks. m_interval_ticks = app_timer_ticks(m_interval * 1000 /* 1000 ms */); // Initialize service structure p_temp->conn_handle = BLE_CONN_HANDLE_INVALID; p_temp->notify_enabled = false; // Add service ble_uuid128_t base_uuid = {TEMP_UUID_BASE}; err_code = sd_ble_uuid_vs_add(&base_uuid, &p_temp->uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = p_temp->uuid_type; ble_uuid.uuid = TEMP_UUID_SERVICE; err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_temp->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } err_code = temperature_char_add(p_temp); if (err_code != NRF_SUCCESS) { return err_code; } err_code = interval_char_add(p_temp); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }