void test_key(char *rd2, t_char **list, char **envp)
{
int i;
int ret;
i = 0;
ret = 0;
while (i < 21)
{
if (rd2[0] == (g_t[i]).rd[0] && rd2[1] == (g_t[i]).rd[1]
&& rd2[2] == g_t[i].rd[2] && rd2[3] == g_t[i].rd[3])
{
ret = g_t[i].fct(list, envp);
break ;
}
i++;
}
if (ret == 1)
return ;
if (rd2[0] && rd2[1] == 0 && rd2[2] == 0 && rd2[3] == 0)
{
char_add(list, char_new(rd2[0]));
refresh_command_line(list);
}
else if (rd2[0] != 27 || rd2[1] != 91 || rd2[2] != 49 || rd2[3] != 59)
refresh_command_line(list);
}
/**@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);
}
int main(int argc, char **argv, char **envp)
{
t_char *list;
t_env **env;
(void)argc;
(void)argv;
list = NULL;
char_add(&list, char_new('-'));
*(getactivelist()) = &list;
env = ft_getenv();
*env = ft_load_env(envp);
(ft_saved_env())->home = ft_strdup(get_env_value("HOME"));
term_initiate();
ft_putstr_fd("$> ", *(gettty()));
*(getcurpos()) = 3;
show_prompt(&list, envp);
return (0);
}
uint32_t ble_dis_init(const ble_dis_init_t * p_dis_init)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_DEVICE_INFORMATION_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add characteristics
if (p_dis_init->manufact_name_str.length > 0)
{
err_code = char_add(BLE_UUID_MANUFACTURER_NAME_STRING_CHAR,
p_dis_init->manufact_name_str.p_str,
p_dis_init->manufact_name_str.length,
&p_dis_init->dis_attr_md,
&manufact_name_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
if (p_dis_init->model_num_str.length > 0)
{
err_code = char_add(BLE_UUID_MODEL_NUMBER_STRING_CHAR,
p_dis_init->model_num_str.p_str,
p_dis_init->model_num_str.length,
&p_dis_init->dis_attr_md,
&model_num_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
if (p_dis_init->serial_num_str.length > 0)
{
err_code = char_add(BLE_UUID_SERIAL_NUMBER_STRING_CHAR,
p_dis_init->serial_num_str.p_str,
p_dis_init->serial_num_str.length,
&p_dis_init->dis_attr_md,
&serial_num_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
if (p_dis_init->hw_rev_str.length > 0)
{
err_code = char_add(BLE_UUID_HARDWARE_REVISION_STRING_CHAR,
p_dis_init->hw_rev_str.p_str,
p_dis_init->hw_rev_str.length,
&p_dis_init->dis_attr_md,
&hw_rev_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
if (p_dis_init->fw_rev_str.length > 0)
{
err_code = char_add(BLE_UUID_FIRMWARE_REVISION_STRING_CHAR,
p_dis_init->fw_rev_str.p_str,
p_dis_init->fw_rev_str.length,
&p_dis_init->dis_attr_md,
&fw_rev_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
if (p_dis_init->sw_rev_str.length > 0)
{
err_code = char_add(BLE_UUID_SOFTWARE_REVISION_STRING_CHAR,
p_dis_init->sw_rev_str.p_str,
p_dis_init->sw_rev_str.length,
&p_dis_init->dis_attr_md,
&sw_rev_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
if (p_dis_init->p_sys_id != NULL)
{
uint8_t encoded_sys_id[BLE_DIS_SYS_ID_LEN];
sys_id_encode(encoded_sys_id, p_dis_init->p_sys_id);
err_code = char_add(BLE_UUID_SYSTEM_ID_CHAR,
encoded_sys_id,
BLE_DIS_SYS_ID_LEN,
&p_dis_init->dis_attr_md,
&sys_id_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
if (p_dis_init->p_reg_cert_data_list != NULL)
{
err_code = char_add(BLE_UUID_IEEE_REGULATORY_CERTIFICATION_DATA_LIST_CHAR,
p_dis_init->p_reg_cert_data_list->p_list,
p_dis_init->p_reg_cert_data_list->list_len,
&p_dis_init->dis_attr_md,
®_cert_data_list_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
if (p_dis_init->p_pnp_id != NULL)
{
uint8_t encoded_pnp_id[BLE_DIS_PNP_ID_LEN];
pnp_id_encode(encoded_pnp_id, p_dis_init->p_pnp_id);
err_code = char_add(BLE_UUID_PNP_ID_CHAR,
encoded_pnp_id,
BLE_DIS_PNP_ID_LEN,
&p_dis_init->dis_attr_md,
&pnp_id_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
return NRF_SUCCESS;
}
ret_code_t nrf_ble_escs_init(nrf_ble_escs_t * p_escs, const nrf_ble_escs_init_t * p_escs_init)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
ble_uuid128_t ecs_base_uuid = ESCS_BASE_UUID;
uint8_t zero_val = 0;
VERIFY_PARAM_NOT_NULL(p_escs);
VERIFY_PARAM_NOT_NULL(p_escs_init);
// Initialize the service structure.
p_escs->conn_handle = BLE_CONN_HANDLE_INVALID;
p_escs->write_evt_handler = p_escs_init->write_evt_handler;
p_escs->read_evt_handler = p_escs_init->read_evt_handler;
// Add a custom base UUID.
err_code = sd_ble_uuid_vs_add(&ecs_base_uuid, &p_escs->uuid_type);
VERIFY_SUCCESS(err_code);
ble_uuid.type = p_escs->uuid_type;
ble_uuid.uuid = BLE_UUID_ESCS_SERVICE;
// Add the service.
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&ble_uuid,
&p_escs->service_handle);
VERIFY_SUCCESS(err_code);
m_handle_to_uuid_map_idx = 0;
// Set up initial values for characteristics
// Eddystone spec requires big endian
nrf_ble_escs_broadcast_cap_t temp = p_escs_init->p_init_vals->broadcast_cap;
temp.supp_frame_types = BYTES_SWAP_16BIT(temp.supp_frame_types);
nrf_ble_escs_adv_interval_t temp_interval = p_escs_init->p_init_vals->adv_interval;
temp_interval = BYTES_SWAP_16BIT(temp_interval);
// Adding chracteristics
err_code = char_add(&BROADCAST_CAP_CHAR_INIT, p_escs,
&temp, &p_escs->broadcast_cap_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&ACTIVE_SLOT_CHAR_INIT, p_escs,
p_escs->p_active_slot, &p_escs->active_slot_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&ADV_INTERVAL_CHAR_INIT, p_escs,
&temp_interval, &p_escs->adv_interval_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&RADIO_TX_PWR_CHAR_INIT, p_escs,
&(p_escs_init->p_init_vals->radio_tx_pwr), &p_escs->radio_tx_pwr_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&ADV_TX_PWR_CHAR_INIT, p_escs,
&(p_escs_init->p_init_vals->adv_tx_pwr), &p_escs->adv_tx_pwr_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&LOCK_STATE_CHAR_INIT, p_escs,
p_escs->p_lock_state, &p_escs->lock_state_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&UNLOCK_CHAR_INIT, p_escs,
&zero_val, &p_escs->unlock_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&PUBLIC_ECDH_KEY_CHAR_INIT, p_escs,
&zero_val, &p_escs->pub_ecdh_key_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&EID_ID_KEY_CHAR_INIT, p_escs,
&zero_val, &p_escs->eid_id_key_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&RW_ADV_SLOT_CHAR_INIT, p_escs,
&zero_val, &p_escs->rw_adv_slot_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&FACTORY_RESET_CHAR_INIT, p_escs,
&(p_escs_init->p_init_vals->factory_reset), &p_escs->factory_reset_handles);
VERIFY_SUCCESS(err_code);
err_code = char_add(&REMAIN_CONNECTABLE_CHAR_INIT, p_escs,
&(p_escs_init->p_init_vals->remain_connectable.r_is_non_connectable_supported),
&p_escs->remain_connectable_handles);
VERIFY_SUCCESS(err_code);
return NRF_SUCCESS;
}
