mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-02-09 12:39:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

gap.h: use gap_ instead of le_central_ or gap_le_

Browse Source
This commit is contained in:
Matthias Ringwald 2016-02-12 17:04:41 +01:00
parent 33885e447f
commit d8e8f12ab0
13 changed files with 142 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
example/embedded/gap_le_advertisements.c
View File

@ -240,8 +240,8 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
// BTstack activated, get started
if (packet[2] == HCI_STATE_WORKING) {
printf("BTstack activated, start scaning!\n");
le_central_set_scan_parameters(0,0x0030, 0x0030);
le_central_start_scan();
gap_set_scan_parameters(0,0x0030, 0x0030);
gap_start_scan();
}
break;
case GAP_LE_EVENT_ADVERTISING_REPORT:{

12
example/embedded/gatt_battery_query.c
View File

@ -176,7 +176,7 @@ static void handle_gatt_client_event(uint8_t packet_type, uint16_t channel, uint
if (!packet[4]){
printf("Battery service not found. Restart scan.\n");
state = TC_W4_SCAN_RESULT;
le_central_start_scan();
gap_start_scan();
break;
}
state = TC_W4_CHARACTERISTIC_RESULT;
@ -248,22 +248,22 @@ static void hci_event_handler(uint8_t packet_type, uint16_t channel, uint8_t *pa
if (cmdline_addr_found){
printf("Start connect to %s\n", bd_addr_to_str(cmdline_addr));
state = TC_W4_CONNECT;
le_central_connect(cmdline_addr, 0);
gap_connect(cmdline_addr, 0);
break;
}
printf("BTstack activated, start scanning!\n");
state = TC_W4_SCAN_RESULT;
le_central_set_scan_parameters(0,0x0030, 0x0030);
le_central_start_scan();
gap_set_scan_parameters(0,0x0030, 0x0030);
gap_start_scan();
break;
case GAP_LE_EVENT_ADVERTISING_REPORT:
if (state != TC_W4_SCAN_RESULT) return;
fill_advertising_report_from_packet(&report, packet);
// stop scanning, and connect to the device
state = TC_W4_CONNECT;
le_central_stop_scan();
gap_stop_scan();
printf("Stop scan. Start connect to device with addr %s.\n", bd_addr_to_str(report.address));
le_central_connect(report.address,report.address_type);
gap_connect(report.address,report.address_type);
break;
case HCI_EVENT_LE_META:
// wait for connection complete

10
example/embedded/gatt_browser.c
View File

@ -193,18 +193,18 @@ static void handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *pac
if (packet[2] != HCI_STATE_WORKING) break;
if (cmdline_addr_found){
printf("Trying to connect to %s\n", bd_addr_to_str(cmdline_addr));
le_central_connect(cmdline_addr, 0);
gap_connect(cmdline_addr, 0);
break;
}
printf("BTstack activated, start scanning!\n");
le_central_set_scan_parameters(0,0x0030, 0x0030);
le_central_start_scan();
gap_set_scan_parameters(0,0x0030, 0x0030);
gap_start_scan();
break;
case GAP_LE_EVENT_ADVERTISING_REPORT:
fill_advertising_report_from_packet(&report, packet);
// stop scanning, and connect to the device
le_central_stop_scan();
le_central_connect(report.address,report.address_type);
gap_stop_scan();
gap_connect(report.address,report.address_type);
break;
case HCI_EVENT_LE_META:
// wait for connection complete

10
platform/daemon/daemon.c
View File

@ -1155,21 +1155,21 @@ static int btstack_command_handler(connection_t *connection, uint8_t *packet, ui
// sdp_general_query_for_uuid(addr, SDP_PublicBrowseGroup);
break;
case GAP_LE_SCAN_START:
le_central_start_scan();
gap_start_scan();
break;
case GAP_LE_SCAN_STOP:
le_central_stop_scan();
gap_stop_scan();
break;
case GAP_LE_SET_SCAN_PARAMETERS:
le_central_set_scan_parameters(packet[3], little_endian_read_16(packet, 4), little_endian_read_16(packet, 6));
gap_set_scan_parameters(packet[3], little_endian_read_16(packet, 4), little_endian_read_16(packet, 6));
break;
case GAP_LE_CONNECT:
bt_flip_addr(addr, &packet[4]);
addr_type = packet[3];
le_central_connect(addr, addr_type);
gap_connect(addr, addr_type);
break;
case GAP_LE_CONNECT_CANCEL:
le_central_connect_cancel();
gap_connect_cancel();
break;
case GAP_DISCONNECT:
handle = little_endian_read_16(packet, 3);

8
port/arduino/BTstack.cpp
View File

@ -299,7 +299,7 @@ static void gatt_client_callback(uint8_t packet_type, uint8_t * packet, uint16_t
static void connection_timeout_handler(btstack_timer_source_t * timer){
// log_info("Cancel outgoing connection");
le_central_connect_cancel();
gap_le_connect_cancel();
if (!bleDeviceConnectedCallback) return;
(*bleDeviceConnectedCallback)(BLE_STATUS_CONNECTION_TIMEOUT, NULL); // page timeout 0x04
}
@ -704,7 +704,7 @@ void BTstackManager::bleConnect(BD_ADDR_TYPE address_type, const char * address,
// log_error("BTstackManager::bleConnect(BD_ADDR_TYPE address_type, const char * address, int timeout_ms) not implemented");
}
void BTstackManager::bleConnect(BD_ADDR_TYPE address_type, const uint8_t address[6], int timeout_ms){
le_central_connect((uint8_t*)address, (bd_addr_type_t) address_type);
gap_le_connect((uint8_t*)address, (bd_addr_type_t) address_type);
if (!timeout_ms) return;
btstack_run_loop_set_timer(&connection_timer, timeout_ms);
btstack_run_loop_set_timer_handler(&connection_timer, connection_timeout_handler);
@ -818,10 +818,10 @@ void BTstackManager::loop(void){
void BTstackManager::bleStartScanning(void){
printf("Start scanning\n");
le_central_start_scan();
gap_le_start_scan();
}
void BTstackManager::bleStopScanning(void){
le_central_stop_scan();
gap_le_stop_scan();
}
void BTstackManager::setGATTCharacteristicRead(uint16_t (*cb)(uint16_t characteristic_id, uint8_t * buffer, uint16_t buffer_size)){

4
src/ble/gatt_client.c
View File

@ -1678,11 +1678,11 @@ uint8_t gatt_client_write_client_characteristic_configuration(btstack_packet_han
if ( (configuration & GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_NOTIFICATION) &&
(characteristic->properties & ATT_PROPERTY_NOTIFY) == 0) {
log_info("le_central_write_client_characteristic_configuration: GATT_CLIENT_CHARACTERISTIC_NOTIFICATION_NOT_SUPPORTED");
log_info("gatt_client_write_client_characteristic_configuration: GATT_CLIENT_CHARACTERISTIC_NOTIFICATION_NOT_SUPPORTED");
return GATT_CLIENT_CHARACTERISTIC_NOTIFICATION_NOT_SUPPORTED;
} else if ( (configuration & GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_INDICATION) &&
(characteristic->properties & ATT_PROPERTY_INDICATE) == 0){
log_info("le_central_write_client_characteristic_configuration: GATT_CLIENT_CHARACTERISTIC_INDICATION_NOT_SUPPORTED");
log_info("gatt_client_write_client_characteristic_configuration: GATT_CLIENT_CHARACTERISTIC_INDICATION_NOT_SUPPORTED");
return GATT_CLIENT_CHARACTERISTIC_INDICATION_NOT_SUPPORTED;
}

129
src/gap.h
View File

@ -104,6 +104,30 @@ typedef enum {
/* API_START */
// Classic + LE
/**
* @brief Disconnect connection with handle
* @param handle
*/
uint8_t gap_disconnect(hci_con_handle_t handle);
/**
* @brief Get connection type
* @param con_handle
* @result connection_type
*/
gap_connection_type_t gap_get_connection_type(hci_con_handle_t connection_handle);
// Classic
/**
* @brief Sets local name.
* @note has to be done before stack starts up
* @param name is not copied, make sure memory is accessible during stack startup
*/
void gap_set_local_name(const char * local_name);
/**
* @brief Enable/disable bonding. Default is enabled.
* @param enabled
@ -129,22 +153,25 @@ gap_security_level_t gap_security_level_for_link_key_type(link_key_type_t link_k
gap_security_level_t gap_security_level(hci_con_handle_t con_handle);
void gap_request_security_level(hci_con_handle_t con_handle, gap_security_level_t level);
int gap_mitm_protection_required_for_security_level(gap_security_level_t level);
/**
* @brief Sets local name.
* @note has to be done before stack starts up
* @param name is not copied, make sure memory is accessible during stack startup
*/
void gap_set_local_name(const char * local_name);
/* API_END*/
// LE
/**
* @brief Get connection type
* @param con_handle
* @result connection_type
* @brief Set parameters for LE Scan
*/
gap_connection_type_t gap_get_connection_type(hci_con_handle_t connection_handle);
void gap_set_scan_parameters(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window);
/**
* @brief Start LE Scan
*/
void gap_start_scan(void);
/**
* @brief Stop LE Scan
*/
void gap_stop_scan(void);
/**
* @brief Enable privacy by using random addresses
@ -170,30 +197,6 @@ gap_random_address_type_t gap_random_address_get_mode(void);
*/
void gap_random_address_set(bd_addr_t addr);
/**
* @brief Updates the connection parameters for a given LE connection
* @param handle
* @param conn_interval_min (unit: 1.25ms)
* @param conn_interval_max (unit: 1.25ms)
* @param conn_latency
* @param supervision_timeout (unit: 10ms)
* @returns 0 if ok
*/
int gap_update_connection_parameters(hci_con_handle_t con_handle, uint16_t conn_interval_min,
uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout);
/**
* @brief Request an update of the connection parameter for a given LE connection
* @param handle
* @param conn_interval_min (unit: 1.25ms)
* @param conn_interval_max (unit: 1.25ms)
* @param conn_latency
* @param supervision_timeout (unit: 10ms)
* @returns 0 if ok
*/
int gap_request_connection_parameter_update(hci_con_handle_t con_handle, uint16_t conn_interval_min,
uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout);
/**
* @brief Set Advertisement Data
* @param advertising_data_length
@ -221,6 +224,51 @@ void gap_advertisements_set_params(uint16_t adv_int_min, uint16_t adv_int_max, u
* @param enabled
*/
void gap_advertisements_enable(int enabled);
/**
* @brief Request an update of the connection parameter for a given LE connection
* @param handle
* @param conn_interval_min (unit: 1.25ms)
* @param conn_interval_max (unit: 1.25ms)
* @param conn_latency
* @param supervision_timeout (unit: 10ms)
* @returns 0 if ok
*/
int gap_request_connection_parameter_update(hci_con_handle_t con_handle, uint16_t conn_interval_min,
uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout);
/**
* @brief Updates the connection parameters for a given LE connection
* @param handle
* @param conn_interval_min (unit: 1.25ms)
* @param conn_interval_max (unit: 1.25ms)
* @param conn_latency
* @param supervision_timeout (unit: 10ms)
* @returns 0 if ok
*/
int gap_update_connection_parameters(hci_con_handle_t con_handle, uint16_t conn_interval_min,
uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout);
/**
* @brief Set accepted connection parameter range
* @param range
*/
void gap_get_connection_parameter_range(le_connection_parameter_range_t range);
/**
* @brief Get accepted connection parameter range
* @param range
*/
void gap_set_connection_parameter_range(le_connection_parameter_range_t range);
/**
* @brief Connect to remote LE device
*/
uint8_t gap_connect(bd_addr_t addr, bd_addr_type_t addr_type);
/**
* @brief Cancel connection process initiated by gap_connect
*/
uint8_t gap_connect_cancel(void);
/**
* @brief Auto Connection Establishment - Start Connecting to device
@ -244,17 +292,8 @@ int gap_auto_connection_stop(bd_addr_type_t address_typ, bd_addr_t address);
*/
void gap_auto_connection_stop_all(void);
void gap_le_get_connection_parameter_range(le_connection_parameter_range_t range);
void gap_le_set_connection_parameter_range(le_connection_parameter_range_t range);
/* LE Client Start */
uint8_t le_central_start_scan(void);
uint8_t le_central_stop_scan(void);
uint8_t le_central_connect(bd_addr_t addr, bd_addr_type_t addr_type);
uint8_t le_central_connect_cancel(void);
uint8_t gap_disconnect(hci_con_handle_t handle);
void le_central_set_scan_parameters(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window);
/* API_END*/
#if defined __cplusplus
}

34
src/hci.c
View File

@ -147,7 +147,7 @@ static hci_connection_t * create_connection_for_bd_addr_and_type(bd_addr_t addr,
*
* @return le connection parameter range struct
*/
void gap_le_get_connection_parameter_range(le_connection_parameter_range_t range){
void gap_get_connection_parameter_range(le_connection_parameter_range_t range){
range = hci_stack->le_connection_parameter_range;
}
@ -156,7 +156,7 @@ void gap_le_get_connection_parameter_range(le_connection_parameter_range_t range
*
*/
void gap_le_set_connection_parameter_range(le_connection_parameter_range_t range){
void gap_set_connection_parameter_range(le_connection_parameter_range_t range){
hci_stack->le_connection_parameter_range = range;
}
@ -3189,40 +3189,38 @@ void gap_set_local_name(const char * local_name){
hci_stack->local_name = local_name;
}
uint8_t le_central_start_scan(void){
if (hci_stack->le_scanning_state == LE_SCANNING) return 0;
void gap_start_scan(void){
if (hci_stack->le_scanning_state == LE_SCANNING) return;
hci_stack->le_scanning_state = LE_START_SCAN;
hci_run();
return 0;
}
uint8_t le_central_stop_scan(void){
if ( hci_stack->le_scanning_state == LE_SCAN_IDLE) return 0;
void gap_stop_scan(void){
if ( hci_stack->le_scanning_state == LE_SCAN_IDLE) return;
hci_stack->le_scanning_state = LE_STOP_SCAN;
hci_run();
return 0;
}
void le_central_set_scan_parameters(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window){
void gap_set_scan_parameters(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window){
hci_stack->le_scan_type = scan_type;
hci_stack->le_scan_interval = scan_interval;
hci_stack->le_scan_window = scan_window;
hci_run();
}
uint8_t le_central_connect(bd_addr_t addr, bd_addr_type_t addr_type){
uint8_t gap_connect(bd_addr_t addr, bd_addr_type_t addr_type){
hci_connection_t * conn = hci_connection_for_bd_addr_and_type(addr, addr_type);
if (!conn){
log_info("le_central_connect: no connection exists yet, creating context");
log_info("gap_connect: no connection exists yet, creating context");
conn = create_connection_for_bd_addr_and_type(addr, addr_type);
if (!conn){
// notify client that alloc failed
hci_emit_le_connection_complete(addr_type, addr, 0, BTSTACK_MEMORY_ALLOC_FAILED);
log_info("le_central_connect: failed to alloc hci_connection_t");
log_info("gap_connect: failed to alloc hci_connection_t");
return GATT_CLIENT_NOT_CONNECTED; // don't sent packet to controller
}
conn->state = SEND_CREATE_CONNECTION;
log_info("le_central_connect: send create connection next");
log_info("gap_connect: send create connection next");
hci_run();
return 0;
}
@ -3231,18 +3229,18 @@ uint8_t le_central_connect(bd_addr_t addr, bd_addr_type_t addr_type){
conn->state == SEND_CREATE_CONNECTION ||
conn->state == SENT_CREATE_CONNECTION) {
hci_emit_le_connection_complete(conn->address_type, conn->address, 0, ERROR_CODE_COMMAND_DISALLOWED);
log_error("le_central_connect: classic connection or connect is already being created");
log_error("gap_connect: classic connection or connect is already being created");
return GATT_CLIENT_IN_WRONG_STATE;
}
log_info("le_central_connect: context exists with state %u", conn->state);
log_info("gap_connect: context exists with state %u", conn->state);
hci_emit_le_connection_complete(conn->address_type, conn->address, conn->con_handle, 0);
hci_run();
return 0;
}
// @assumption: only a single outgoing LE Connection exists
static hci_connection_t * le_central_get_outgoing_connection(void){
static hci_connection_t * gap_get_outgoing_connection(void){
btstack_linked_item_t *it;
for (it = (btstack_linked_item_t *) hci_stack->connections; it ; it = it->next){
hci_connection_t * conn = (hci_connection_t *) it;
@ -3258,8 +3256,8 @@ static hci_connection_t * le_central_get_outgoing_connection(void){
return NULL;
}
uint8_t le_central_connect_cancel(void){
hci_connection_t * conn = le_central_get_outgoing_connection();
uint8_t gap_connect_cancel(void){
hci_connection_t * conn = gap_get_outgoing_connection();
if (!conn) return 0;
switch (conn->state){
case SEND_CREATE_CONNECTION:

2
src/l2cap.c
View File

@ -1445,7 +1445,7 @@ static void l2cap_acl_handler(uint8_t packet_type, uint8_t *packet, uint16_t siz
}
int update_parameter = 1;
le_connection_parameter_range_t existing_range;
gap_le_get_connection_parameter_range(existing_range);
gap_get_connection_parameter_range(existing_range);
uint16_t le_conn_interval_min = little_endian_read_16(packet,12);
uint16_t le_conn_interval_max = little_endian_read_16(packet,14);
uint16_t le_conn_latency = little_endian_read_16(packet,16);

2
test/btstack_link_key_db/btstack_link_key_db_fs_test.c
View File

@ -6,9 +6,9 @@
#include "classic/btstack_link_key_db.h"
#include "btstack_link_key_db_fs.h"
#include "btstack_util.h"
#include "btstack_config.h"
TEST_GROUP(RemoteDeviceDB){
bd_addr_t bd_addr;
link_key_t link_key;

6
test/gatt_client/le_central.c
View File

@ -48,8 +48,8 @@ static void handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *pac
switch (event) {
case BTSTACK_EVENT_STATE:
if (packet[2] != HCI_STATE_WORKING) break;
le_central_set_scan_parameters(0,0x0030, 0x0030);
le_central_start_scan();
gap_set_scan_parameters(0,0x0030, 0x0030);
gap_start_scan();
break;
case GAP_LE_EVENT_ADVERTISING_REPORT:{
@ -57,7 +57,7 @@ static void handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *pac
memcpy(advertisement_packet, packet, size);
reverse_bd_addr(&packet[4], address);
le_central_connect(address, (bd_addr_type_t)packet[3]);
gap_connect(address, (bd_addr_type_t)packet[3]);
break;
}
case HCI_EVENT_LE_META:

12
test/gatt_client/mock.c
View File

@ -43,16 +43,14 @@ void mock_simulate_scan_response(void){
registered_hci_event_handler(HCI_EVENT_PACKET, 0, (uint8_t *)&packet, sizeof(packet));
}
uint8_t le_central_start_scan(void){
return 0;
void gap_start_scan(void){
}
uint8_t le_central_stop_scan(void){
void gap_stop_scan(void){
}
uint8_t gap_connect(bd_addr_t addr, bd_addr_type_t addr_type){
return 0;
}
uint8_t le_central_connect(bd_addr_t addr, bd_addr_type_t addr_type){
return 0;
}
void le_central_set_scan_parameters(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window){
void gap_set_scan_parameters(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window){
}
static void att_init_connection(att_connection_t * att_connection){

16
test/pts/ble_central_test.c
View File

@ -1417,37 +1417,37 @@ static void ui_process_command(char buffer){
printf("Auto Connection Establishment to type %u, addr %s -> %x\n", current_pts_address_type, bd_addr_to_str(current_pts_address), res);
break;
case 'P':
le_central_connect(current_pts_address, current_pts_address_type);
gap_connect(current_pts_address, current_pts_address_type);
printf("Direct Connection Establishment to type %u, addr %s\n", current_pts_address_type, bd_addr_to_str(current_pts_address));
break;
case 's':
if (scanning_active){
le_central_stop_scan();
gap_stop_scan();
scanning_active = 0;
break;
}
printf("Start passive scanning\n");
le_central_set_scan_parameters(0, 48, 48);
le_central_start_scan();
gap_set_scan_parameters(0, 48, 48);
gap_start_scan();
scanning_active = 1;
break;
case 'S':
if (scanning_active){
printf("Stop scanning\n");
le_central_stop_scan();
gap_stop_scan();
scanning_active = 0;
break;
}
printf("Start active scanning\n");
le_central_set_scan_parameters(1, 48, 48);
le_central_start_scan();
gap_set_scan_parameters(1, 48, 48);
gap_start_scan();
scanning_active = 1;
break;
case 't':
printf("Terminating connection\n");
hci_send_cmd(&hci_disconnect, handle, 0x13);
gap_auto_connection_stop_all();
le_central_connect_cancel();
gap_connect_cancel();
break;
case 'w':
pts_privacy_flag = 2;