LiJie
/
MXC_A39_20240320
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
MXC_A39_20240320/SW/components/btdm/include/gap_api.h

1172 lines
46 KiB
C
Raw Normal View History

800*320工程文件+初始demo提交
2024-03-07 16:46:43 +08:00
/*
****************************************************************************************
*
* @file gap_api.h
* @version v1.0
* @brief GAP API exposed to app layer
* @attention
* Copyright (C) 2022 Freqchip. \n
* All rights reserved. \n
*
*
****************************************************************************************
*/
#ifndef _GAP_API_H
#define _GAP_API_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include <stdbool.h>
#include <stdint.h>
#include "gap_defines.h"
#include "ble_api_error.h"
/* Exported types ------------------------------------------------------------*/
enum gap_event_type {
GAP_EVT_ADV_SET_PARAM, //!< Set advertising parameter ended
GAP_EVT_ADV_SET_ADV_DATA, //!< Set advertising data ended
GAP_EVT_ADV_SET_SCAN_RSP, //!< Set advertising scan response data ended
GAP_EVT_ADV_SET_PER_DATA, //!< Set periodic advertising data ended
GAP_EVT_ADV_START,
GAP_EVT_ADV_END, //!< Advertising ended
GAP_EVT_SCAN_START,
GAP_EVT_SCAN_END, //!< Scanning ended
GAP_EVT_ADV_REPORT, //!< Scan result report
GAP_EVT_CONN_START,
GAP_EVT_CONN_END, //!< Connecion action is ended
GAP_EVT_NAME_REQ, //!< Name request from peer device through GAP
GAP_EVT_SLAVE_PREF_PARAM, //!< Slave prefer parameter from peer device through GAP
GAP_EVT_APPEARANCE_REQ, //!< Appearance request from peer device through GAP
GAP_EVT_SLAVE_CONNECT, //!< Connected as slave role
GAP_EVT_MASTER_CONNECT, //!< Connected as master role
GAP_EVT_DISCONNECT, //!< Connection is removed
GAP_EVT_LINK_PARAM_REQ, //!< Parameter update request
GAP_EVT_LINK_PARAM_REJECT, //!< Parameter update rejected
GAP_EVT_LINK_PARAM_UPDATE, //!< Parameter update successful
GAP_EVT_SMP_TK_REQ, //!< reqeust Temporary Key in pairing procedure
GAP_EVT_SMP_NC_REQ, //!< Send Numbric Comparision to app layer
GAP_EVT_SMP_BOND_SUCCESS, //!< Link bond is successful
GAP_EVT_SMP_BOND_FAILED, //!< Link bond is failed
GAP_EVT_SMP_ENCRYPT_SUCCESS, //!< Link encrypt successful
GAP_EVT_SMP_ENCRYPT_FAILED, //!< Link encrypt failed
GAP_EVT_SMP_SEC_REQ, //!< Recvive security request from slave
GAP_EVT_SMP_PAIR_REQ, //!< Recvive pair request from master, need to call
GAP_EVT_SMP_ENCRYPT_REQ, //!< Recvive encrypt request from master
GATT_EVT_MTU, //!< Mtu updated
GAP_EVT_PHY_REJECT, //!< Parameter update rejected
GAP_EVT_PHY_IND, //!< PHY update indication or read phy success
GAP_EVT_LINK_FEATURE, //!< Got peer device supported features
GAP_EVT_LINK_RSSI, //!< Got RSSI value of link peer device
GAP_EVT_LINK_VER, //!< Got version value of link peer device
GAP_EVT_ADD_DEVICE_TO_WL, //!< Result of add device to white list
GAP_EVT_RMV_DEVICE_FROM_WL, //!< Result pf remove device from white list
GAP_EVT_ADD_DEVICE_TO_RAL, //!< Result of add device to resolve list
GATT_EVT_PROFILE_ADDED, //!< GATT profile have been added
};
enum gap_adv_state {
GAP_ADV_STATE_NONE, //!< Advertising not created.
GAP_ADV_STATE_IDLE, //!< Successfully setting advertising parameters or stopping advertising will be in this state.
GAP_ADV_STATE_CREATING, //!< After calling gap_adv_set_param() and before reporting the GAP_EVT_ADV_SET_PARAM event, will be in this state.
GAP_ADV_STATE_STARTING, //!< After calling gap_adv_start() and before reporting the GAP_EVT_ADV_START event, will be in this state.
GAP_ADV_STATE_WORKING, //!< After reporting the GAP_EVT_ADV_START event and status is 0x00, will be in this state.
GAP_ADV_STATE_STOPPING, //!< After calling gap_adv_stop() and before reporting the GAP_EVT_ADV_STOP event, will be in this state.
GAP_ADV_STATE_DELETING,
};
enum gap_own_addr_type {
GAP_ADDR_TYPE_STATIC, //!< Public or Private Static Address according to device address configuration
GAP_ADDR_TYPE_GEN_RSLV, //!< Generated resolvable private random address
GAP_ADDR_TYPE_GEN_NON_RSLV, //!< Generated non-resolvable private random address
};
enum gap_adv_mode {
GAP_ADV_MODE_UNDIRECT = 0x01,
GAP_ADV_MODE_DIRECT = 0x02,
GAP_ADV_MODE_NON_CONN_NON_SCAN = 0x03,
GAP_ADV_MODE_NON_CONN_SCAN = 0x04,
GAP_ADV_MODE_HDC_DIRECT = 0x05,
GAP_ADV_MODE_BEACON = 0x06,
GAP_ADV_MODE_EXTEND_CONN_UNDIRECT = 0x11,
GAP_ADV_MODE_EXTEND_CONN_DIRECT = 0x12,
GAP_ADV_MODE_EXTEND_NON_CONN_SCAN = 0x13,
GAP_ADV_MODE_EXTEND_NON_CONN_SCAN_DIRECT = 0x14,
GAP_ADV_MODE_EXTEND_NON_CONN_NON_SCAN = 0x15,
GAP_ADV_MODE_EXTEND_NON_CONN_NON_SCAN_DIRECT = 0x16,
GAP_ADV_MODE_PER_ADV_UNDIRECT = 0x21,
GAP_ADV_MODE_PER_ADV_DIRECT = 0x22,
};
enum gap_adv_chan {
GAP_ADV_CHAN_37 = 0x01,
GAP_ADV_CHAN_38 = 0x02,
GAP_ADV_CHAN_39 = 0x04,
GAP_ADV_CHAN_ALL = 0x07,
};
enum gap_adv_filter {
GAP_ADV_FILTER_SCAN_ANY_CON_ANY = 0x00, //!< The Link Layer shall process scan and connection requests from all devices.
GAP_ADV_FILTER_SCAN_WLST_CON_ANY = 0x01, //!< The Link Layer shall process connection requests from all devices,
//!< and shall only process scan requests from devices that are in the White List.
GAP_ADV_FILTER_SCAN_ANY_CON_WLST = 0x02, //!< The Link Layer shall process scan requests from all devices,
//!< and shall only process connection requests from devices that are in the White List.
GAP_ADV_FILTER_SCAN_WLST_CON_WLST = 0x03, //!< The Link Layer shall process scan and connection requests only from
//!< devices in the White List
};
enum gap_adv_disc_mode {
GAP_ADV_DISC_MODE_NON_DISC = 0, //!< Non-Discoverable mode
//!< This mode of package will be filtered out in the host layer.
GAP_ADV_DISC_MODE_GEN_DISC = 1, //!< General Discoverable mopde
//!< Except for scan mode GAP_SCAN_TYPE_GEN_DISC,
//!< other scan modes will filter out this mode of package at the host layer
GAP_ADV_DISC_MODE_LIM_DISC = 2, //!< Limited Discoverable mopde
//!< This mode of package will automatically stop within a certain period of time
//!< Can be received by devices using GAP_SCAN_TYPE_GEN_DISC and GAP_SCAN_TYPE_LIM_DISC scanning modes
GAP_ADV_DISC_MODE_BEACON = 3,
};
enum gap_scan_type {
GAP_SCAN_TYPE_GEN_DISC = 0, //!< General discovery, active scanning
GAP_SCAN_TYPE_LIM_DISC = 1, //!< Limited discovery, active scanning
GAP_SCAN_TYPE_OBSERVER = 2, //!< Observer, passive scanning
GAP_SCAN_TYPE_SEL_OBSERVER = 3, //!< Selective observer, passive scanning, only receive advertising data from whitelist
GAP_SCAN_TYPE_CONN_DISC = 4, //!< Connectable discovery
GAP_SCAN_TYPE_SEL_CONN_DISC = 5, //!< Selective connectable discovery
};
enum gap_phy_type {
/// LE 1M
GAP_PHY_TYPE_LE_1M = (1<<0),
/// LE 2M
GAP_PHY_TYPE_LE_2M = (1<<1),
/// LE Coded
GAP_PHY_TYPE_LE_CODED = (1<<2),
};
enum smp_tk_type {
GAP_TK_TYPE_OOB,
GAP_TK_TYPE_DISPLAY, //!< Display TK(pin code)
GAP_TK_TYPE_ENTRY, //!< Input TK(pin code)
};
enum gap_sec_mode {
ENABLE_AUTO_RSP, //!< Automatically reply to pairing or encryption requests
DISABLE_AUTO_RSP, //!< Pairing or encryption requests will be reported to the GAP callback function
//!< The user will decide whether to reply or not
//!< Callback event is either GAP_EVT_SMP_PAIR_REQ or GAP_EVT_SMP_ENCRYPT_REQ
};
enum local_device_con_role {
LOCAL_ROLE_MASTER = 0,
LOCAL_ROLE_SLAVE,
LOCAL_ROLE_NONE,
};
enum adv_type_flag{
AUTO_ADV_TYPE_FLAG,
USER_SET_ADV_TYPE_FLAG,
};
/** @defgroup GAP_ADVTYPE_DEFINES GAP Advertisement Data Types
* These are the data type identifiers for the data tokens in the advertisement data field.
* @{
*/
#define GAP_ADTVYPE_FLAGS 0x01 //!< Discovery Mode: @ref GAP_ADTYPE_FLAGS_MODES
#define GAP_ADVTYPE_16BIT_MORE 0x02 //!< Service: More 16-bit UUIDs available
#define GAP_ADVTYPE_16BIT_COMPLETE 0x03 //!< Service: Complete list of 16-bit UUIDs
#define GAP_ADVTYPE_32BIT_MORE 0x04 //!< Service: More 32-bit UUIDs available
#define GAP_ADVTYPE_32BIT_COMPLETE 0x05 //!< Service: Complete list of 32-bit UUIDs
#define GAP_ADVTYPE_128BIT_MORE 0x06 //!< Service: More 128-bit UUIDs available
#define GAP_ADVTYPE_128BIT_COMPLETE 0x07 //!< Service: Complete list of 128-bit UUIDs
#define GAP_ADVTYPE_LOCAL_NAME_SHORT 0x08 //!< Shortened local name
#define GAP_ADVTYPE_LOCAL_NAME_COMPLETE 0x09 //!< Complete local name
#define GAP_ADVTYPE_POWER_LEVEL 0x0A //!< TX Power Level: 0xXX: -127 to +127 dBm
#define GAP_ADVTYPE_OOB_CLASS_OF_DEVICE 0x0D //!< Simple Pairing OOB Tag: Class of device (3 octets)
#define GAP_ADVTYPE_OOB_SIMPLE_PAIRING_HASHC 0x0E //!< Simple Pairing OOB Tag: Simple Pairing Hash C (16 octets)
#define GAP_ADVTYPE_OOB_SIMPLE_PAIRING_RANDR 0x0F //!< Simple Pairing OOB Tag: Simple Pairing Randomizer R (16 octets)
#define GAP_ADVTYPE_SM_TK 0x10 //!< Security Manager TK Value
#define GAP_ADVTYPE_SM_OOB_FLAG 0x11 //!< Secutiry Manager OOB Flags
#define GAP_ADVTYPE_SLAVE_CONN_INTERVAL_RANGE 0x12 //!< Min and Max values of the connection interval (2 octets Min, 2 octets Max) (0xFFFF indicates no conn interval min or max)
#define GAP_ADVTYPE_SIGNED_DATA 0x13 //!< Signed Data field
#define GAP_ADVTYPE_SERVICES_LIST_16BIT 0x14 //!< Service Solicitation: list of 16-bit Service UUIDs
#define GAP_ADVTYPE_SERVICES_LIST_128BIT 0x15 //!< Service Solicitation: list of 128-bit Service UUIDs
#define GAP_ADVTYPE_SERVICE_DATA 0x16 //!< Service Data - 16-bit UUID
#define GAP_ADVTYPE_PUBLIC_TARGET_ADDR 0x17 //!< Public Target Address
#define GAP_ADVTYPE_RANDOM_TARGET_ADDR 0x18 //!< Random Target Address
#define GAP_ADVTYPE_APPEARANCE 0x19 //!< Appearance
#define GAP_ADVTYPE_ADV_INTERVAL 0x1A //!< Advertising Interval
#define GAP_ADVTYPE_LE_BD_ADDR 0x1B //!< LE Bluetooth Device Address
#define GAP_ADVTYPE_LE_ROLE 0x1C //!< LE Role
#define GAP_ADVTYPE_SIMPLE_PAIRING_HASHC_256 0x1D //!< Simple Pairing Hash C-256
#define GAP_ADVTYPE_SIMPLE_PAIRING_RANDR_256 0x1E //!< Simple Pairing Randomizer R-256
#define GAP_ADVTYPE_SERVICE_DATA_32BIT 0x20 //!< Service Data - 32-bit UUID
#define GAP_ADVTYPE_SERVICE_DATA_128BIT 0x21 //!< Service Data - 128-bit UUID
#define GAP_ADVTYPE_3D_INFO_DATA 0x3D //!< 3D Information Data
#define GAP_ADVTYPE_MANUFACTURER_SPECIFIC 0xFF //!< Manufacturer Specific Data: first 2 octets contain the Company Identifier Code followed by the additional manufacturer specific data
/** @} End GAP_ADVTYPE_DEFINES */
/** @defgroup GAP_SCAN_EVT_TYPE_DEFINES GAP Event Types
* @{
*/
#define GAP_SCAN_EVT_CONN_UNDIR 0x00 //!< Undirected advertising
#define GAP_SCAN_EVT_CONN_DIR 0x01 //!< Directed advertising
#define GAP_SCAN_EVT_NONCONN_UNDIR 0x02 //!< Non Connectable advertising
#define GAP_SCAN_EVT_SCAN_RSP 0x04 //!< Scan Response
#define GAP_SCAN_EVT_NONCONN_NONSCAN 0x08 //!< Non Connectable Non Scan advertising
#define GAP_SCAN_EVT_EXT_ADV 0x10 //!< Scan Response of extended adv
#define GAP_SCAN_EVT_EXT_SCAN_RSP 0x14 //!< Scan Response of extended scan response
#define GAP_SCAN_EVT_PER_ADV 0x20 //!< Periodic adv
/** @} EndGAP_SCAN_EVT_TYPE_DEFINES */
/** @defgroup GAP_APPEARANCE_VALUES GAP Appearance Values
* @{
*/
#define GAP_APPEARE_UNKNOWN 0x0000 //!< Unknown
#define GAP_APPEARE_GENERIC_PHONE 0x0040 //!< Generic Phone
#define GAP_APPEARE_GENERIC_COMPUTER 0x0080 //!< Generic Computer
#define GAP_APPEARE_GENERIC_WATCH 0x00C0 //!< Generic Watch
#define GAP_APPEARE_WATCH_SPORTS 0x00C1 //!< Watch: Sports Watch
#define GAP_APPEARE_GENERIC_CLOCK 0x0100 //!< Generic Clock
#define GAP_APPEARE_GENERIC_DISPLAY 0x0140 //!< Generic Display
#define GAP_APPEARE_GENERIC_RC 0x0180 //!< Generic Remote Control
#define GAP_APPEARE_GENERIC_EYE_GALSSES 0x01C0 //!< Generic Eye-glasses
#define GAP_APPEARE_GENERIC_TAG 0x0200 //!< Generic Tag
#define GAP_APPEARE_GENERIC_KEYRING 0x0240 //!< Generic Keyring
#define GAP_APPEARE_GENERIC_MEDIA_PLAYER 0x0280 //!< Generic Media Player
#define GAP_APPEARE_GENERIC_BARCODE_SCANNER 0x02C0 //!< Generic Barcode Scanner
#define GAP_APPEARE_GENERIC_THERMOMETER 0x0300 //!< Generic Thermometer
#define GAP_APPEARE_GENERIC_THERMO_EAR 0x0301 //!< Thermometer: Ear
#define GAP_APPEARE_GENERIC_HR_SENSOR 0x0340 //!< Generic Heart rate Sensor
#define GAP_APPEARE_GENERIC_HRS_BELT 0x0341 //!< Heart Rate Sensor: Heart Rate Belt
#define GAP_APPEARE_GENERIC_BLOOD_PRESSURE 0x0380 //!< Generic Blood Pressure
#define GAP_APPEARE_GENERIC_BP_ARM 0x0381 //!< Blood Pressure: Arm
#define GAP_APPEARE_GENERIC_BP_WRIST 0x0382 //!< Blood Pressure: Wrist
#define GAP_APPEARE_GENERIC_HID 0x03C0 //!< Generic Human Interface Device (HID)
#define GAP_APPEARE_HID_KEYBOARD 0x03C1 //!< HID Keyboard
#define GAP_APPEARE_HID_MOUSE 0x03C2 //!< HID Mouse
#define GAP_APPEARE_HID_JOYSTIC 0x03C3 //!< HID Joystick
#define GAP_APPEARE_HID_GAMEPAD 0x03C4 //!< HID Gamepad
#define GAP_APPEARE_HID_DIGITIZER_TYABLET 0x03C5 //!< HID Digitizer Tablet
#define GAP_APPEARE_HID_DIGITAL_CARDREADER 0x03C6 //!< HID Card Reader
#define GAP_APPEARE_HID_DIGITAL_PEN 0x03C7 //!< HID Digital Pen
#define GAP_APPEARE_HID_BARCODE_SCANNER 0x03C8 //!< HID Barcode Scanner
/** @} End GAP_APPEARANCE_VALUES */
struct gap_ble_addr {
uint8_t addr_type; //!< Address type: 0=public/1=random
struct {
uint8_t addr[6];
} addr; //!< Address value
};
typedef struct gap_adv_param {
enum gap_adv_mode adv_mode; //!< Advertising mode, ref @ gap_adv_mode
enum gap_adv_disc_mode disc_mode; //!< Advertising discovery mode, ref @gap_adv_disc_mode
//!< When adv_mode is in directional mode, disc_mode should be set to GAP_ADV_DISC_MODE_NON_DISC
//!< When adv_mode is GAP_ADV_MODE_BEACON, disc_mode should be set to GAP_ADV_DISC_MODE_BEACON
enum gap_adv_filter filt_policy; //!< Advertising filter policy, ref @ gap_adv_filter
//!< When disc_mode is GAP_ADV_DISC_MODE_GEN_DISC or GAP_ADV_DISC_MODE_LIM_DISC,
//!< filt_policy should be set to GAP_ADV_FILTER_SCAN_ANY_CON_ANY
enum gap_adv_chan adv_chnl_map; //!< Advertising channal map, 37, 38, 39, ref @ gap_adv_chan
enum gap_phy_type phy_mode; //!< ref @gap_phy_type
enum gap_own_addr_type own_addr_type; //!< Own address type, ref @gap_own_addr_type
struct gap_ble_addr peer_addr; //!< Peer addr used for connect, used for direction adv
uint16_t adv_intv_min; //!< Minimum advertising interval, (in unit of 625us). Must >= 32
uint16_t adv_intv_max; //!< Maximum advertising interval, (in unit of 625us). Must >= 32
/* the following is for secondary advertising configuration */
uint8_t max_skip; //!< Maximum number of advertising events the controller can skip before sending the
//!< AUX_ADV_IND packets. 0 means that AUX_ADV_IND PDUs shall be sent prior each
//!< advertising events
enum gap_phy_type second_phy_mode; //!< PHY mode for secondary advertising ref @gap_phy_type
uint8_t adv_sid; //!< Advertising set idx, for EXTENDED adv and PERIODIC ADV only, range:0~0xF
/* the following is for periodic advertising */
uint16_t per_adv_intv_min; //!< Minimum periodic advertising interval (in unit of 1.25ms).. Must be greater than 20ms,for PERIODIC ADV only
uint16_t per_adv_intv_max; //!< Maximum periodic advertising interval (in unit of 1.25ms). Must be greater than 20ms,for PERIODIC ADV only
}gap_adv_param_t;
typedef struct gap_scan_param {
enum gap_scan_type scan_type; //!< scan type, ref @ gap_scan_type
enum gap_own_addr_type own_addr_type; //!< Own address type, ref @gap_own_addr_type
enum gap_phy_type phy_mode; //!< ref @gap_phy_type
uint8_t dup_filt_pol; //!< scan duplicated pkt filter enbale, 0, donot filter; 1 filter duplicated pkt
uint16_t scan_intv; //!< scan interval, (in unit of 625us). range [4,16384]
uint16_t scan_window; //!< scan window, (in unit of 625us). must <= scan_intv, range [4,16384]
uint16_t duration; //!< Scan duration (in unit of 10ms). 0 means that the controller will scan continuously until host stop it
}gap_scan_param_t;
typedef struct gap_conn_param {
struct gap_ble_addr peer_addr; //!< Peer addr used for connect
enum gap_own_addr_type own_addr_type; //!< Own address type, ref @gap_own_addr_type
enum gap_phy_type phy_mode; //!< ref @gap_phy_type
uint16_t scan_intv; //!< scan interval, (in unit of 625us). range [4,16384]
uint16_t scan_window; //!< scan window, (in unit of 625us). must <= scan_intv, range [4,16384]
uint16_t conn_intv_min; //!< connection minimum interval (in unit of 1.25ms), should less than conn_intv_max
uint16_t conn_intv_max; //!< connection maximum interval (in unit of 1.25ms), range is 7.5ms to 4s
uint16_t supervision_to; //!< link supervision timeout (in unit of 10ms)
uint16_t slave_latency; //!< number of events than can be missed by a connected slave device
uint16_t ce_len_min; //!< maximum duration of connection event (in unit of 625us)
uint16_t ce_len_max; //!< minumum duration of connection event (in unit of 625us)
}gap_conn_param_t;
typedef struct gap_evt_adv_report {
uint8_t evt_type; //!< Bit field providing information about the received report (@see GAP_SCAN_EVT_TYPE_DEFINES)
struct gap_ble_addr addr; //!< Target address (in case of a directed advertising report)
int8_t tx_pwr; //!< TX power (in dBm)
int8_t rssi; //!< RSSI (between -127 and +20 dBm)
uint16_t length; //!< Report length
const uint8_t *data; //!< Report data
}gap_evt_adv_report_t;
typedef struct gap_evt_conn_param
{
uint8_t conidx; //!< Connection index
struct gap_ble_addr peer_addr; //!< Peer addr used for connect
uint16_t con_interval; //!< Connection interval
uint16_t con_latency; //!< Slave latency
uint16_t sup_to; //!< Supervision timeout
}gap_evt_conn_param_t;
typedef struct gap_evt_disconnect
{
uint8_t conidx; //!< Connection index
uint8_t reason; //!< Disconnect reason
}gap_evt_disconnect_t;
typedef struct gap_evt_link_param_reject {
uint8_t conidx; //!< Connection index
uint8_t status; //!< Parameter reject status
}gap_evt_link_param_reject_t;
typedef struct gap_evt_link_param_update {
uint8_t conidx; //!< Connection index
uint16_t con_interval; //!< Connection interval
uint16_t con_latency; //!< Connection latency value
uint16_t sup_to; //!< Supervision timeout
}gap_evt_link_param_update_t;
typedef struct gap_evt_link_param_update_req {
uint8_t conidx; //!< Connection index
uint16_t intv_min; //!< Connection interval minimum
uint16_t intv_max; //!< Connection interval maximum
uint16_t latency; //!< Latency
uint16_t time_out; //!< Supervision timeout
}gap_evt_link_param_update_req_t;
// Link parameter update rsponse event
typedef struct gap_evt_link_param_update_rsp {
bool accept;
uint8_t conidx; //!< Connection index
uint16_t ce_len_min; //!< Mimimum Connection Event Duration
uint16_t ce_len_max; //!< Maximum Connection Event Duration
}gap_evt_link_param_update_rsp_t;
typedef struct gap_link_param_update_req {
uint8_t conidx; //!< Connection index
uint16_t intv_min; //!< Connection interval minimum
uint16_t intv_max; //!< Connection interval maximum
uint16_t latency; //!< Latency
uint16_t time_out; //!< Supervision timeout
}gap_link_param_update_req_t;
typedef struct gap_link_param_update_rsp {
bool accept;
uint8_t conidx; //!< Connection index
uint16_t ce_len_min; //!< Mimimum Connection Event Duration
uint16_t ce_len_max; //!< Maximum Connection Event Duration
}gap_link_param_update_rsp_t;
typedef struct gap_security_param {
bool mitm; //!< Man In The Middle mode enalbe/disable
bool secure_connection; //!< BLE Secure Simple Pairing, also called Secure Connection mode.
bool bond; //!< Bond or not, if true, then will distribute encryption key, and will check this key_req when bonding.
enum gap_sec_mode rsp_mode; //!< Security rsp mode, ref @enum gap_sec_mode
enum gap_oob oob_used; //!< Oob data exists or not, ref @enum gap_oob
enum gap_io_cap io_cap; //!< IO capbilities, ref @enum gap_io_cap
}gap_security_param_t;
typedef struct gap_bond_ltk {
uint8_t ltk[16]; //!< Long Term Key
uint16_t ediv; //!< Encryption Diversifier
uint8_t randnb[8]; //!< Random Number
uint8_t key_size; //!< Encryption key size (7 to 16)
}gap_bond_ltk_t;
typedef struct gap_bond_info {
uint8_t conidx; //!< Connection index
uint8_t status; //!< Pairing results, 0x00 means success
struct gap_ble_addr peer_addr; //!< Peer addr used for connect
struct gap_ble_addr peer_id_addr; //!< Peer identity address
uint8_t peer_irk[16]; //!< Peer irk
struct gap_bond_ltk peer_ltk; //!< Peer ltk
}gap_bond_info_t;
typedef struct gap_channel_map {
uint8_t conidx; //!< Connection index
uint8_t map[5]; //!< 5-byte channel map array
}gap_channel_map_t;
struct gap_event {
enum gap_event_type type; //!< GAP event type
union {
uint8_t conidx;
struct {
uint8_t act_id;
uint8_t status;
} adv_set_param;
struct {
uint8_t act_id;
uint8_t status;
} adv_set_adv_data;
struct {
uint8_t act_id;
uint8_t status;
} adv_set_scan_rsp;
struct {
uint8_t act_id;
uint8_t status;
} adv_set_period_data;
struct {
uint8_t act_id;
uint8_t status;
} adv_start;
struct {
uint8_t act_id;
uint8_t status;
} adv_end; //!< Advertising end status
uint8_t scan_start_status; //!< Scanning end status
uint8_t scan_end_status; //!< Scanning end status
struct gap_evt_adv_report *adv_rpt; //!< Value of GAP_EVT_ADV_REPORT event, scanning results
uint8_t conn_start_status; //!< Connection end reason
uint8_t conn_end_status; //!< Connection end reason
struct {
uint8_t conidx;
uint8_t token;
} name_req; //!< Value of GAP_EVT_NAME_REQ event
struct {
uint8_t conidx;
uint8_t token;
} slv_pref_param_req; //!< Value of GAP_EVT_SLAVE_PREF_PARAM event
struct {
uint8_t conidx;
uint8_t token;
} appearance_req; //!< Value of GAP_EVT_APPEARANCE_REQ event
struct gap_evt_conn_param connect; //!< Value of GAP_EVT_MASTER_CONNECT or GAP_EVT_SLAVE_CONNECT event
struct gap_evt_disconnect disconnect; //!< Value of GAP_EVT_DISCONNECT event
struct {
uint8_t conidx;
uint32_t number;
} nc_req; //!< Value of GAP_EVT_SMP_NC_REQ
struct {
uint8_t conidx;
enum smp_tk_type tk_type;
} tk_req; //!< Value of GAP_EVT_SMP_TK_REQ event
struct {
uint8_t conidx;
} pair_req; //!< Value of GAP_EVT_SMP_PAIR_REQ event
struct {
uint8_t conidx;
} security_req; //!< Value of GAP_EVT_SMP_SEC_REQ event
struct gap_bond_info bond; //!< Value of GAP_EVT_SMP_BOND_SUCCESS and GAP_EVT_SMP_BOND_FAILED event
struct {
uint8_t conidx;
uint8_t ltk[16]; //!< Can be used for gap_encrypt_rsp()
} encrypt_req; //!< Value of GAP_EVT_SMP_ENCRYPT_REQ event
struct {
uint8_t conidx;
uint8_t status; //!< Encrypt status, 0x00 means success
} encrypt; //!< Value of GAP_EVT_SMP_ENCRYPT_SUCCESS or GAP_EVT_SMP_ENCRYPT_FAILED event
struct gap_evt_link_param_reject link_param_reject; //!< Value of GAP_EVT_LINK_PARAM_REJECT event, Connect param reject
struct gap_evt_link_param_update link_param_update; //!< Value of GAP_EVT_LINK_PARAM_UPDATE event, Connect param update
struct gap_evt_link_param_update_req link_param_update_req; //!< Value of GAP_EVT_LINK_PARAM_REQ event
struct gap_evt_link_param_update_rsp link_param_update_rsp;
struct {
uint8_t conidx;
uint16_t mtu;
} mtu_ind; //!< Value of GATT_EVT_MTU event, mtu update indication
struct {
uint8_t conidx;
int8_t link_rssi; //!< Peer device RSSI value
} gap_link_rssi; //!< Value of GAP_EVT_LINK_RSSI event
struct {
uint8_t conidx; //!< Connection index
uint16_t compid; //!< Manufacturer name
uint16_t lmp_subvers; //!< LMP subversion
uint8_t lmp_vers; //!< LMP version
} gap_link_ver; //!< Value of GAP_EVT_LINK_VER event
struct {
uint8_t conidx; //!< Connection index
uint8_t features[8]; //!< Features bitmask
} gap_link_feature; //!< Value of GAP_EVT_LINK_FEATURE event
struct {
uint8_t conidx;
uint8_t tx_phy; //!< ref @gapm_phy_type
uint8_t rx_phy; //!< ref @gapm_phy_type
} gap_phy_ind; //!< Value of GAP_EVT_PHY_IND event, PHY update success event or get phy success
struct {
uint8_t conidx;
uint8_t status; //!< Reason of reject
} gap_phy_update_reject; //!< Value of GAP_EVT_PHY_REJECT event, PHY update rejected event
uint8_t add_device_to_wl_status; //!< Value of GAP_EVT_ADD_DEVICE_TO_WL event
uint8_t rmv_device_from_wl_status; //!< Value of GAP_EVT_RMV_DEVICE_FROM_WL event
uint8_t add_device_to_ral_status; //!< Value of GAP_EVT_ADD_DEVICE_TO_TAL event
uint8_t profile_added_status; //!< Value of GATT_EVT_PROFILE_ADDED event, profile added status
} param;
};
typedef void *adv_handle;
typedef uint16_t(*gap_callback_func_t)(struct gap_event *event); //!< Gap callback function define
/* Exported constants --------------------------------------------------------*/
/* Exported macro ------------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/* Exported variables --------------------------------------------------------*/
extern gap_callback_func_t gap_evt_callback;
/* Exported functions --------------------------------------------------------*/
/*
* @fn gap_reset_local_address
*
* @brief reset local static address(public or random static).
* Must stop advertising before configure.
* After address change, the advertising parameters and data must be reset
*
* @param[in] new_addr : pointer to new address info
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_reset_local_address(struct gap_ble_addr *new_addr);
/*
* @fn gap_adv_create
*
* @brief Create an advertising activity before any advertising operation. This
* function will return a handle used by following operations.
*
* @return operation handle
*/
adv_handle gap_adv_create(void);
/*
* @fn gap_get_adv_state
*
* @brief Obtain the state of the specified advertising.
*
* @param[in] adv : advertising operation handle
*
* @return enum gap_adv_state
*/
enum gap_adv_state gap_get_adv_state(adv_handle adv);
/*
* @fn gap_adv_set_param
*
* @brief used to create advertising entity with parameters defined by user
*
* @param[in] adv : advertising operation handle
* @param[in] param : advertising parameters
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_adv_set_param(adv_handle adv, struct gap_adv_param *param);
/*
* @fn gap_adv_set_adv_type_flag
*
* @brief user to set advertising type flag
*
* @param[in] adv_type: adv type flag
*
* @return None
*/
void gap_adv_set_adv_type_flag(enum adv_type_flag adv_type);
/*
* @fn gap_adv_set_adv_data
*
* @brief used to set advertising data
*
* @param[in] adv : advertising operation handle
* @param[in] data : advertising data buffer pointer
* @param[in] length : advertising data length
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_adv_set_adv_data(adv_handle adv, const uint8_t *data, uint16_t length);
/*
* @fn gap_adv_set_scan_rsp
*
* @brief used to set scan response data
*
* @param[in] adv : advertising operation handle
* @param[in] data : scan response data buffer pointer
* @param[in] length : scan response data length
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_adv_set_scan_rsp(adv_handle adv, const uint8_t *data, uint16_t length);
/*
* @fn gap_adv_set_period_data
*
* @brief used to set periodic advertising data
*
* @param[in] adv : advertising operation handle
* @param[in] data : periodic advertising data buffer pointer
* @param[in] length : periodic advertising data length
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_adv_set_period_data(adv_handle adv, const uint8_t *data, uint16_t length);
/*
* @fn gap_adv_start
*
* @brief start advertising
*
* @param[in] adv : advertising operation handle
* @param[in] duration : advertising duration, unit: 10ms. 0 means that advertising will not terminate
* automaticly.
* @param[in] max_adv_evt : Maximum number of extended advertising events the controller shall attempt to send prior to
* terminating the extending advertising. Valid only if extended advertising.
* 0 means taht extended advertising events will always be sent
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_adv_start(adv_handle adv, uint16_t duration, uint8_t max_adv_evt);
/*
* @fn gap_adv_stop
*
* @brief stop on-going advertising
*
* @param[in] adv : advertising operation handle
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_adv_stop(adv_handle adv);
/*
* @fn gap_scan_start
*
* @brief start scan advertising devices
*
* @param[in] param : scan parameters
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_scan_start(struct gap_scan_param *param);
/*
* @fn gap_scan_stop
*
* @brief stop on-going scan
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_scan_stop(void);
/*
* @fn gap_conn_start
*
* @brief start connect request to remote device, this function should not be called when
* there is an on-going connection request.
*
* @param[in] param : connection parameters
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_conn_start(struct gap_conn_param *param);
/*
* @fn gap_conn_stop
*
* @brief stop out-going connection request
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_conn_stop(void);
/*
* @fn gap_disconnect
*
* @brief remove an existing connection
*
* @param[in] conidx : connection index
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_disconnect(uint8_t conidx);
/*
* @fn gap_get_connect_num
*
* @brief get the current active connections number
*
* @return number of active connections
*/
uint8_t gap_get_connect_num(void);
/*
* @fn gap_get_connect_num_through_role
*
* @brief get the current active connections number through local devices role
*
* @param[in] role : local device role
*
* @return number of active connections
*/
uint8_t gap_get_connect_num_through_role(enum local_device_con_role role);
/*
* @fn gap_get_local_role
*
* @brief Get the local device role
*
* @param[in] conidx : connection index
*
* @return the connection role
*/
enum local_device_con_role gap_get_local_dev_role(uint8_t conidx);
/*
* @fn gap_get_connect_status
*
* @brief Get the connection status with a peer device
*
* @param[in] conidx : connection index
*
* @return the connection status
*/
bool gap_get_connect_status(uint8_t conidx);
/*
* @fn gap_act_done
*
* @brief this function will be called after action has been handled by host layer
*
* @param[in] operation : last requested action
* @param[in] status : handle result
* @param[in] act_id : action id
*/
void gap_act_done(uint8_t operation, uint8_t status, uint8_t act_id);
/*
* @fn gap_param_update_rsp
*
* @brief stop out-going connection request
*
* @param[in] rsp : link param update response parameters, @ref gap_evt_link_param_update_rsp
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_param_update_rsp(struct gap_link_param_update_rsp *rsp);
/*
* @fn gap_param_update_req
*
* @brief send connection parameters update request from ble peripheral device.
*
* @param[in] req : link param update request parameters, @ref gap_evt_link_param_update_rsp
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_param_update_req(struct gap_link_param_update_req *req);
/*
* @fn gap_name_req_rsp
*
* @brief send response to name request from GAP
*
* @param[in] conidx: connection index
* @param[in] token: received from GAP_EVT_NAME_REQ
* @param[in] length: name length
* @param[in] name: name string
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_name_req_rsp(uint8_t conidx, uint8_t token, uint16_t length, uint8_t *name);
/*
* @fn gap_appearance_req_rsp
*
* @brief send response to appearance request from GAP
*
* @param[in] conidx: connection index
* @param[in] token: received from GAP_EVT_NAME_REQ
* @param[in] appearance: appearance, see @defgroup GAP_APPEARANCE_VALUES
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_appearance_req_rsp(uint8_t conidx, uint8_t token, uint16_t appearance);
/*
* @fn gap_slave_pref_param_req_rsp
*
* @brief send response to slave prefer parameter request from GAP
*
* @param[in] conidx: connection index
* @param[in] token: received from GAP_EVT_NAME_REQ
* @param[in] con_intv_min: minimum connection interval
* @param[in] con_intv_max: maximum connection interval
* @param[in] slave_latency: slave latency
* @param[in] conn_timeout: connection timeout
*
* @return @ref app_err_t
*/
ble_api_err_t gap_slave_pref_param_req_rsp(uint8_t conidx, uint8_t token,
uint16_t con_intv_min, uint16_t con_intv_max,
uint16_t slave_latency, uint16_t conn_timeout);
/*
* @fn gap_set_cb_func
*
* @brief GAP callback functions set. Links application layer callbacks to GAP layer.
*
* @param[in] gap_evt_cb : Application layer callback function, defined in application layer.
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_set_cb_func(gap_callback_func_t gap_evt_cb);
/*
* @fn gap_security_param_init
*
* @brief Used to set SMP parameters.
*
* @param[in] sec_param : SMP parameters. @ref gap_security_param.
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_security_param_init(struct gap_security_param *sec_param);
/*
* @fn gap_security_tk_rsp
*
* @brief Used to response Temporary Key request from GAP in pairing procedure. When local io-cap is
* GAP_IO_CAP_DISPLAY_ONLY, this function is used to send local generated TK, also this value
* should be showed in display. When local io-cap is GAP_IO_CAP_KB_ONLY, this function is used
* to send local TK input by keyboard.
*
* @param[in] conidx : connection index
* @param[in] tk : temporary key, the value should be between 100000 and 999999
* @param[in] accept: true:Agree to pairing, false:Refuse pairing
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_security_tk_rsp(uint8_t conidx, uint32_t tk, bool accept);
/*
* @fn gap_security_nc_rsp
*
* @brief Used to response Numbric Comparision request from GAP in pairing procedure.
*
* @param[in] conidx : connection index
* @param[in] accept: true:Agree to pairing, false:Refuse pairing
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_security_nc_rsp(uint8_t conidx, bool accept);
/*
* @fn gap_security_req
*
* @brief Used to send security request when the deivice is the slaver
*
* @param[in] conidx : connection index
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_security_req(uint8_t conidx);
/*
* @fn gap_pairing_req
*
* @brief Used to send pairing request when the device is the master
*
* @param[in] conidx : connection index
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_pairing_req(uint8_t conidx);
/*
* @fn gap_pairing_rsp
*
* @brief Used to send pairing response when event GAP_EVT_SMP_PAIR_REQ occurs
*
* @param[in] conidx : connection index
* @param[in] accept : true - Agree to pairing req.
* false - Refuse pairing req
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_pairing_rsp(uint8_t conidx, bool accept);
/*
* @fn gap_encrypt_req
*
* @brief Used to send encrypt request when the device is the master
*
* @param[in] conidx : connection index
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_encrypt_req(uint8_t conidx);
/*
* @fn gap_encrypt_rsp
*
* @brief Used to send encrypt response when event GAP_EVT_SMP_ENCRYPT_REQ occurs
*
* @param[in] conidx : connection index
* @param[in] ltk : long Term Key information
* @param[in] accept : true - Agree to encryption req.
* false - Refuse encryption req
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_encrypt_rsp(uint8_t conidx, uint8_t *ltk, bool accept);
/*
* @fn gap_get_bond_status
*
* @brief Get bond info status of peer device.
*
* @param[in] conidx : connection index
*
* @return @ref true: bond info existed, false: bond info not existed
*/
bool gap_get_bond_status(uint8_t conidx);
/*
* @fn gap_get_encrypted_status
*
* @brief Get encrypted status of peer device.
*
* @param[in] conidx : connection index
*
* @return @ref encrypted status
*/
bool gap_get_encrypted_status(uint8_t conidx);
/*
* @fn gap_get_bond_info
*
* @brief Get a bond information.
*
* @param[in] bond_info_list_index - index of the bond information list in the ble stack.
* range:0 ~ 7.
* @param[in] out_bond_info - pointer to bond info
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_get_bond_info(uint8_t bond_info_list_index, gap_bond_info_t *out_bond_info);
/*
* @fn gap_get_bond_info_by_conidx
*
* @brief Get a bond information by conidx.
* The device of this conidx needs to be in a connected state.
*
* @param[in] conidx : connection index
* @param[in] out_bond_info - pointer to bond info
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_get_bond_info_by_conidx(uint8_t conidx, gap_bond_info_t *out_bond_info);
/*
* @fn gap_delete_bond_info
*
* @brief Erase a bond information.
*
* @param[in] peer_id_addr - pointer to peer device identity address
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_delete_bond_info(struct gap_ble_addr *peer_id_addr);
/*
* @fn gap_deletet_all_bond_info
*
* @brief Erase all bond information.
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_deletet_all_bond_info(void);
/*
* @fn gap_get_conn_phy
*
* @brief Read active link PHY mode.
* The phy report will be uploaded to user laye as GAP_EVENT:GAP_EVT_PHY_IND.
* This function sample is:
* case GAP_EVT_PHY_IND:
* co_printf("link tx phy: %d\r\n",event->param.gap_phy_ind.tx_phy);
* ...
* break;
*
* @param[in] conidx : connection index
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_get_conn_phy(uint8_t conidx);
/*
* @fn gap_conn_phy_update
*
* @brief Set active link PHY mode.
*
* @param[in] conidx : connection handle/index of the connection.
* @param[in] tx_phy : TX PHY mode. //!< see @enum gapm_phy_mode
* @param[in] rx_phy : RX PHY mode. //!< see @enum gapm_phy_mode
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_conn_phy_update(uint8_t conidx, enum gap_phy_type tx_phy, enum gap_phy_type rx_phy);
/*
* @fn gap_get_link_rssi
*
* @brief Used to send a request to lower layer to get current rssi of link peer device.
* The rssi report will be uploaded to user laye as GAP_EVENT:GAP_EVT_LINK_RSSI.
* This function sample is:
* case GAP_EVT_LINK_RSSI:
* co_printf("link rssi: %d\r\n",event->param.gap_link_rssi.link_rssi);
* ...
* break;
*
* @param[in] conidx : connection index
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_get_link_rssi(uint8_t conidx);
/*
* @fn gap_get_link_features
*
* @brief Used to send a request to lower layer to get features of link peer device.
* The feature report will be uploaded to user laye as GAP_EVENT:GAP_EVT_LINK_FEATURE.
*
* @param[in] conidx : connection index
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_get_link_features(uint8_t conidx);
/*
* @fn gap_get_link_version
*
* @brief Used to send a request to lower layer to get version info of link peer device.
* The phy report will be uploaded to user laye as GAP_EVENT:GAP_EVT_LINK_VER.
*
* @param[in] conidx : connection index
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_get_link_version(uint8_t conidx);
/*
* @fn gap_add_device_to_white_list
*
* @brief Add device to white list.
*
* @param[in] peer_id_addr - pointer to peer device identity address, which will be added to white list
* @param[in] size - device number,rang:1~22. how many devices will be added to white list
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_add_device_to_white_list(struct gap_ble_addr *peer_id_addr, uint8_t size);
/*
* @fn gap_remove_device_from_white_list
*
* @brief Remove device from white list.
*
* @param[in] peer_id_addr - pointer to peer device identity address, which will be removed from white list
* @param[in] size - device number,range:0~22. how many devices will be removed from white list.
* when size is 0, All devices in the white list will be removed
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_remove_device_from_white_list(struct gap_ble_addr *peer_id_addr, uint8_t size);
/*
* @fn gap_add_device_to_resolve_list
*
* @brief Add device to resolve list.
*
* @param[in] peer_id_addr - pointer to peer device identity address, which will be added to resolve list
* @param[in] irk_array - peer device irk array.Each irk has a length of 16.
* @param[in] size - device number,range:1~3. how many devices will be added to resolve list.
*
* @return @ref ble_api_err_t
*/
ble_api_err_t gap_add_device_to_resolve_list(struct gap_ble_addr *peer_id_addr, uint8_t *irk_array, uint8_t size);
#ifdef __cplusplus
}
#endif
#endif // _GAP_API_H