rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/services/ble_stack/hl/api/gap.h

1048 lines
34 KiB
C
Raw Blame History

#ifndef GAP_H_
#define GAP_H_
/**
****************************************************************************************
* @addtogroup HOST
* @ingroup ROOT
* @brief Bluetooth Low Energy Host
*
* The HOST layer of the stack contains the higher layer protocols (@ref ATT "ATT",
* @ref SMP "SMP") and transport module (@ref L2C "L2C"). It also includes the Generic
* Access Profile (@ref GAP "GAP"), used for scanning/connection operations.
****************************************************************************************
*/
/**
****************************************************************************************
* @addtogroup GAP Generic Access Profile
* @ingroup HOST
* @brief Generic Access Profile.
*
* The GAP module is responsible for providing an API to the application in order to
* configure the device in the desired mode (discoverable, connectable, etc.) and perform
* required actions (scanning, connection, pairing, etc.). To achieve this, the GAP
* interfaces with both the @ref SMP "SMP", @ref L2C "L2C" and the @ref CONTROLLER "CONTROLLER"
*
* @{
****************************************************************************************
*/
#include <stdint.h>
#include "compiler.h"
/*
* DEFINES
****************************************************************************************
*/
/// BD address length
#define GAP_BD_ADDR_LEN (6)
/// LE Channel map length
#define GAP_LE_CHNL_MAP_LEN (0x05)
/// LE Feature Flags Length
#define GAP_LE_FEATS_LEN (0x08)
/// ADV Data and Scan Response length
#define GAP_ADV_DATA_LEN (0x1F)
#define GAP_SCAN_RSP_DATA_LEN (0x1F)
/// Random number length
#define GAP_RAND_NB_LEN (0x08)
/// Key length
#define GAP_KEY_LEN (16)
/// P256 Key Len
#define GAP_P256_KEY_LEN (0x20)
///***** AD Type Flag - Bit set *******/
/// Limited discovery flag - AD Flag
#define GAP_LE_LIM_DISCOVERABLE_FLG 0x01
/// General discovery flag - AD Flag
#define GAP_LE_GEN_DISCOVERABLE_FLG 0x02
/// Legacy BT not supported - AD Flag
#define GAP_BR_EDR_NOT_SUPPORTED 0x04
/// Dual mode for controller supported (BR/EDR/LE) - AD Flag
#define GAP_SIMUL_BR_EDR_LE_CONTROLLER 0x08
/// Dual mode for host supported (BR/EDR/LE) - AD Flag
#define GAP_SIMUL_BR_EDR_LE_HOST 0x10
/*********** GAP Miscellaneous Defines *************/
/// Invalid connection index
#define GAP_INVALID_CONIDX 0xFF
/// Invalid connection handle
#define GAP_INVALID_CONHDL 0xFFFF
/// Connection interval min (N*1.250ms)
#define GAP_CNX_INTERVAL_MIN 6 //(0x06)
/// Connection interval Max (N*1.250ms)
#define GAP_CNX_INTERVAL_MAX 3200 //(0xC80)
/// Connection latency min (N*cnx evt)
#define GAP_CNX_LATENCY_MIN 0 //(0x00)
/// Connection latency Max (N*cnx evt
#define GAP_CNX_LATENCY_MAX 499 //(0x1F3)
/// Supervision TO min (N*10ms)
#define GAP_CNX_SUP_TO_MIN 10 //(0x0A)
/// Supervision TO Max (N*10ms)
#define GAP_CNX_SUP_TO_MAX 3200 //(0xC80)
/// Length of resolvable random address prand part
#define GAP_ADDR_PRAND_LEN (3)
/// Length of resolvable random address hash part
#define GAP_ADDR_HASH_LEN (3)
/*
* DEFINES - Optional for BLE application usage
****************************************************************************************
*/
/// Central idle timer
/// TGAP(conn_pause_central)
/// recommended value: 1 s: (100 for ke timer)
#define GAP_TMR_CONN_PAUSE_CT 0x0064
/// Minimum time upon connection establishment before the peripheral
/// starts a connection update procedure: TGAP(conn_pause_peripheral)
/// recommended value: 5 s: (500 for ke timer)
#define GAP_TMR_CONN_PAUSE_PH 0x01F4
/// Minimum time to perform scanning when user initiated
/// TGAP(scan_fast_period)
/// recommended value: 30.72 s: (3072 for ke timer)
#define GAP_TMR_SCAN_FAST_PERIOD 0x0C00
/// Minimum time to perform advertising when user initiated
/// TGAP(adv_fast_period)
/// recommended value: 30 s: (3000 for ke timer)
#define GAP_TMR_ADV_FAST_PERIOD 0x0BB8
/// Scan interval used during Link Layer Scanning State when
/// performing the Limited Discovery procedure
/// TGAP(lim_disc_scan_int)
/// recommended value: 11.25ms; (18 decimal)
#define GAP_LIM_DISC_SCAN_INT 0x0012
/// Scan interval in any discovery or connection establishment
/// procedure when user initiated: TGAP(scan_fast_interval)
/// recommended value: 30 to 60 ms; N * 0.625
#define GAP_SCAN_FAST_INTV 0x0030
/// Scan window in any discovery or connection establishment
/// procedure when user initiated: TGAP(scan_fast_window)
/// recommended value: 30 ms; N * 0.625
#define GAP_SCAN_FAST_WIND 0x0030
/// Scan interval in any discovery or connection establishment
/// procedure when background scanning: TGAP(scan_slow_interval1)
/// recommended value: 1.28 s : 0x00CD (205); N * 0.625
#define GAP_SCAN_SLOW_INTV1 0x00CD
/// Scan interval in any discovery or connection establishment
/// procedure when background scanning: TGAP(scan_slow_interval2)
/// recommended value: 2.56 s : 0x019A (410); N * 0.625
#define GAP_SCAN_SLOW_INTV2 0x019A
/// Scan window in any discovery or connection establishment
/// procedure when background scanning: TGAP(scan_slow_window1)
/// recommended value: 11.25 ms : 0x0012 (18); N * 0.625
#define GAP_SCAN_SLOW_WIND1 0x0012
/// Scan window in any discovery or connection establishment
/// procedure when background scanning: TGAP(scan_slow_window2)
/// recommended value: 22.5 ms : 0x0024 (36); N * 0.625
#define GAP_SCAN_SLOW_WIND2 0x0024
/// Minimum to maximum advertisement interval in any discoverable
/// or connectable mode when user initiated: TGAP(adv_fast_interval1)
/// recommended value: 30 to 60 ms; N * 0.625
#define GAP_ADV_FAST_INTV1 0x0030
/// Minimum to maximum advertisement interval in any discoverable
/// or connectable mode when user initiated: TGAP(adv_fast_interval2)
/// recommended value: 100 to 150 ms; N * 0.625
#define GAP_ADV_FAST_INTV2 0x0064
/// Minimum to maximum advertisement interval in any discoverable or
/// connectable mode when background advertising: TGAP(adv_slow_interval)
/// recommended value: 1 to 1.2 s : 0x00B0 (176); N * 0.625
#define GAP_ADV_SLOW_INTV 0x00B0
/// Minimum to maximum connection interval upon any connection
/// establishment: TGAP(initial_conn_interval)
/// recommended value: 30 to 50 ms ; N * 1.25 ms
#define GAP_INIT_CONN_MIN_INTV 0x0018
#define GAP_INIT_CONN_MAX_INTV 0x0028
/// RW Defines
#define GAP_INQ_SCAN_INTV 0x0012
#define GAP_INQ_SCAN_WIND 0x0012
/// Connection supervision timeout
/// recommended value: 20s
#define GAP_CONN_SUPERV_TIMEOUT 0x07D0
/// Minimum connection event
/// default value: 0x0000
#define GAP_CONN_MIN_CE 0x0000
/// Maximum connection event
/// default value: 0xFFFF
#define GAP_CONN_MAX_CE 0xFFFF
/// Connection latency
/// default value: 0x0000
#define GAP_CONN_LATENCY 0x0000
/// GAP Device name Characteristic
/// Default device name
#define GAP_DEV_NAME "RIVIERAWAVES-BLE"
/// GAP Appearance or Icon Characteristic - 2 octets
/// Current appearance value is 0x0000 (unknown appearance)
/// Description:
/// http://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.gap.appearance.xml
#define GAP_APPEARANCE 0x0000
///GAP Peripheral Preferred Connection Parameter - 8 octets
#define GAP_PPCP_CONN_INTV_MAX 0x0064
#define GAP_PPCP_CONN_INTV_MIN 0x00C8
#define GAP_PPCP_SLAVE_LATENCY 0x0000
#define GAP_PPCP_STO_MULT 0x07D0
/*
* Enumerations
****************************************************************************************
*/
/// GAP Advertising Flags
enum gap_ad_type
{
/// Flag
GAP_AD_TYPE_FLAGS = 0x01,
/// Use of more than 16 bits UUID
GAP_AD_TYPE_MORE_16_BIT_UUID = 0x02,
/// Complete list of 16 bit UUID
GAP_AD_TYPE_COMPLETE_LIST_16_BIT_UUID = 0x03,
/// Use of more than 32 bit UUD
GAP_AD_TYPE_MORE_32_BIT_UUID = 0x04,
/// Complete list of 32 bit UUID
GAP_AD_TYPE_COMPLETE_LIST_32_BIT_UUID = 0x05,
/// Use of more than 128 bit UUID
GAP_AD_TYPE_MORE_128_BIT_UUID = 0x06,
/// Complete list of 128 bit UUID
GAP_AD_TYPE_COMPLETE_LIST_128_BIT_UUID = 0x07,
/// Shortened device name
GAP_AD_TYPE_SHORTENED_NAME = 0x08,
/// Complete device name
GAP_AD_TYPE_COMPLETE_NAME = 0x09,
/// Transmit power
GAP_AD_TYPE_TRANSMIT_POWER = 0x0A,
/// Class of device
GAP_AD_TYPE_CLASS_OF_DEVICE = 0x0D,
/// Simple Pairing Hash C
GAP_AD_TYPE_SP_HASH_C = 0x0E,
/// Simple Pairing Randomizer
GAP_AD_TYPE_SP_RANDOMIZER_R = 0x0F,
/// Temporary key value
GAP_AD_TYPE_TK_VALUE = 0x10,
/// Out of Band Flag
GAP_AD_TYPE_OOB_FLAGS = 0x11,
/// Slave connection interval range
GAP_AD_TYPE_SLAVE_CONN_INT_RANGE = 0x12,
/// Require 16 bit service UUID
GAP_AD_TYPE_RQRD_16_BIT_SVC_UUID = 0x14,
/// Require 32 bit service UUID
GAP_AD_TYPE_RQRD_32_BIT_SVC_UUID = 0x1F,
/// Require 128 bit service UUID
GAP_AD_TYPE_RQRD_128_BIT_SVC_UUID = 0x15,
/// Service data 16-bit UUID
GAP_AD_TYPE_SERVICE_16_BIT_DATA = 0x16,
/// Service data 32-bit UUID
GAP_AD_TYPE_SERVICE_32_BIT_DATA = 0x20,
/// Service data 128-bit UUID
GAP_AD_TYPE_SERVICE_128_BIT_DATA = 0x21,
/// Public Target Address
GAP_AD_TYPE_PUB_TGT_ADDR = 0x17,
/// Random Target Address
GAP_AD_TYPE_RAND_TGT_ADDR = 0x18,
/// Appearance
GAP_AD_TYPE_APPEARANCE = 0x19,
/// Advertising Interval
GAP_AD_TYPE_ADV_INTV = 0x1A,
/// LE Bluetooth Device Address
GAP_AD_TYPE_LE_BT_ADDR = 0x1B,
/// LE Role
GAP_AD_TYPE_LE_ROLE = 0x1C,
/// Simple Pairing Hash C-256
GAP_AD_TYPE_SPAIR_HASH = 0x1D,
/// Simple Pairing Randomizer R-256
GAP_AD_TYPE_SPAIR_RAND = 0x1E,
/// 3D Information Data
GAP_AD_TYPE_3D_INFO = 0x3D,
/// Manufacturer specific data
GAP_AD_TYPE_MANU_SPECIFIC_DATA = 0xFF,
};
/// Random Address type
enum gap_rnd_addr_type
{
/// Static random address - 11 (MSB->LSB)
GAP_STATIC_ADDR = 0xC0,
/// Private non resolvable address - 01 (MSB->LSB)
GAP_NON_RSLV_ADDR = 0x00,
/// Private resolvable address - 01 (MSB->LSB)
GAP_RSLV_ADDR = 0x40,
};
/// Boolean value set
enum
{
/// Disable
GAP_DISABLE = 0x00,
/// Enable
GAP_ENABLE
};
/// GAP Attribute database handles
/// Generic Access Profile Service
enum
{
GAP_IDX_PRIM_SVC,
GAP_IDX_CHAR_DEVNAME,
GAP_IDX_DEVNAME,
GAP_IDX_CHAR_ICON,
GAP_IDX_ICON,
GAP_IDX_CHAR_SLAVE_PREF_PARAM,
GAP_IDX_SLAVE_PREF_PARAM,
GAP_IDX_CHAR_CNT_ADDR_RESOL,
GAP_IDX_CNT_ADDR_RESOL,
GAP_IDX_NUMBER
};
/****************** GAP Role **********************/
enum gap_role
{
/// No role set yet
GAP_ROLE_NONE = 0x00,
/// Observer role
GAP_ROLE_OBSERVER = 0x01,
/// Broadcaster role
GAP_ROLE_BROADCASTER = 0x02,
/// Master/Central role
GAP_ROLE_CENTRAL = (0x04 | GAP_ROLE_OBSERVER),
/// Peripheral/Slave role
GAP_ROLE_PERIPHERAL = (0x08 | GAP_ROLE_BROADCASTER),
/// Device has all role, both peripheral and central
GAP_ROLE_ALL = (GAP_ROLE_CENTRAL | GAP_ROLE_PERIPHERAL),
/// Debug mode used to force LL configuration on BLE 4.0
GAP_ROLE_DBG_LE_4_0 = 0x80,
};
/// Advertising mode
enum gap_adv_mode
{
/// Mode in non-discoverable
GAP_NON_DISCOVERABLE,
/// Mode in general discoverable
GAP_GEN_DISCOVERABLE,
/// Mode in limited discoverable
GAP_LIM_DISCOVERABLE,
/// Broadcaster mode which is a non discoverable and non connectable mode.
GAP_BROADCASTER_MODE
};
/// Scan mode
enum gap_scan_mode
{
/// Mode in general discovery
GAP_GEN_DISCOVERY,
/// Mode in limited discovery
GAP_LIM_DISCOVERY,
/// Observer mode
GAP_OBSERVER_MODE,
/// Invalid mode
GAP_INVALID_MODE
};
/// IO Capability Values
enum gap_io_cap
{
/// Display Only
GAP_IO_CAP_DISPLAY_ONLY = 0x00,
/// Display Yes No
GAP_IO_CAP_DISPLAY_YES_NO,
/// Keyboard Only
GAP_IO_CAP_KB_ONLY,
/// No Input No Output
GAP_IO_CAP_NO_INPUT_NO_OUTPUT,
/// Keyboard Display
GAP_IO_CAP_KB_DISPLAY,
GAP_IO_CAP_LAST
};
/// TK Type
enum gap_tk_type
{
/// TK get from out of band method
GAP_TK_OOB = 0x00,
/// TK generated and shall be displayed by local device
GAP_TK_DISPLAY,
/// TK shall be entered by user using device keyboard
GAP_TK_KEY_ENTRY
};
/// OOB Data Present Flag Values
enum gap_oob
{
/// OOB Data not present
GAP_OOB_AUTH_DATA_NOT_PRESENT = 0x00,
/// OOB data present
GAP_OOB_AUTH_DATA_PRESENT,
GAP_OOB_AUTH_DATA_LAST
};
/// Authentication mask
enum gap_auth_mask
{
/// No Flag set
GAP_AUTH_NONE = 0,
/// Bond authentication
GAP_AUTH_BOND = (1 << 0),
/// Man In the middle protection
GAP_AUTH_MITM = (1 << 2),
/// Secure Connection
GAP_AUTH_SEC_CON = (1 << 3),
/// Key Notification
GAP_AUTH_KEY_NOTIF = (1 << 4)
};
/// Security Link Level
enum gap_lk_sec_lvl
{
/// No authentication
GAP_LK_NO_AUTH = 0,
/// Unauthenticated link
GAP_LK_UNAUTH,
/// Authenticated link
GAP_LK_AUTH,
/// Secure Connection link
GAP_LK_SEC_CON,
};
/// Authentication Requirements
enum gap_auth
{
/// No MITM No Bonding
GAP_AUTH_REQ_NO_MITM_NO_BOND = (GAP_AUTH_NONE),
/// No MITM Bonding
GAP_AUTH_REQ_NO_MITM_BOND = (GAP_AUTH_BOND),
/// MITM No Bonding
GAP_AUTH_REQ_MITM_NO_BOND = (GAP_AUTH_MITM),
/// MITM and Bonding
GAP_AUTH_REQ_MITM_BOND = (GAP_AUTH_MITM | GAP_AUTH_BOND),
/// SEC_CON and No Bonding
GAP_AUTH_REQ_SEC_CON_NO_BOND = (GAP_AUTH_SEC_CON),
/// SEC_CON and Bonding
GAP_AUTH_REQ_SEC_CON_BOND = (GAP_AUTH_SEC_CON | GAP_AUTH_BOND),
GAP_AUTH_REQ_LAST,
/// Mask of authentication features without reserved flag
GAP_AUTH_REQ_MASK = 0x1F,
};
/// Key Distribution Flags
enum gap_kdist
{
/// No Keys to distribute
GAP_KDIST_NONE = 0x00,
/// Encryption key in distribution
GAP_KDIST_ENCKEY = (1 << 0),
/// IRK (ID key)in distribution
GAP_KDIST_IDKEY = (1 << 1),
/// CSRK(Signature key) in distribution
GAP_KDIST_SIGNKEY= (1 << 2),
/// LTK in distribution
GAP_KDIST_LINKKEY= (1 << 3),
GAP_KDIST_LAST = (1 << 4)
};
/// Security Defines
enum gap_sec_req
{
/// No security (no authentication and encryption)
GAP_NO_SEC = 0x00,
/// Unauthenticated pairing with encryption
GAP_SEC1_NOAUTH_PAIR_ENC,
/// Authenticated pairing with encryption
GAP_SEC1_AUTH_PAIR_ENC,
/// Unauthenticated pairing with data signing
GAP_SEC2_NOAUTH_DATA_SGN,
/// Authentication pairing with data signing
GAP_SEC2_AUTH_DATA_SGN,
/// Secure Connection pairing with encryption
GAP_SEC1_SEC_CON_PAIR_ENC,
};
/// Bit field use to select the preferred TX or RX LE PHY Rate. 0 means no preferences
enum gap_rate
{
/// No preferred rate
GAP_RATE_ANY = 0x00,
/// LE PHY 1mb/s preferred rate for an active link
GAP_RATE_LE_1MBPS = (1 << 0),
/// LE PHY 2mb/s preferred rate for an active link
GAP_RATE_LE_2MBPS = (1 << 1),
};
/// API settings bit field values
enum gap_api_settings
{
/// Use deprecated API and do not use extended air operations
GAP_ADD_INFO_USE_DEPRECATED_API_BIT = (1 << 0),
};
/// Privacy configuration
enum gap_priv_cfg
{
/// Indicate if public or static private random address must be used by default
GAP_PRIV_CFG_PRIV_ADDR_BIT = (1 << 0),
/// Bit 1 is reserved
GAP_PRIV_CFG_RSVD = (1 << 1),
/// Indicate if controller privacy is enabled
GAP_PRIV_CFG_CTNL_PRIV_BIT = (1 << 2),
};
/// Type of own address
enum gap_own_addr_type
{
/// Use address configured using GAPM_SET_DEV_CONFIG_CMD.
/// Can be either a public address or a random static address
GAP_OWN_ADDR_TYPE_DEFAULT = 0,
/// Use a non-resolvable private address
GAP_OWN_ADDR_TYPE_NRPA,
/// Use a resolvable private address
GAP_OWN_ADDR_TYPE_RPA,
};
/// Type of activities that can be created
enum gap_actv_type
{
/// Advertising activity
GAP_ACTV_TYPE_ADV = 0,
/// Scanning activity
GAP_ACTV_TYPE_SCAN,
/// Initiating activity
GAP_ACTV_TYPE_INIT,
/// Periodic synchronization activity
GAP_ACTV_TYPE_PERIOD_SYNC,
};
/// Type of advertising that can be created
enum gap_adv_type
{
/// Legacy advertising
GAP_ADV_TYPE_LEGACY = 0,
/// Extended advertising
GAP_ADV_TYPE_EXTENDED,
/// Periodic advertising
GAP_ADV_TYPE_PERIODIC,
};
/// Advertising report type
enum gap_adv_report_type
{
/// Extended advertising report
GAP_REPORT_TYPE_ADV_EXT = 0,
/// Legacy advertising report
GAP_REPORT_TYPE_ADV_LEG,
/// Extended scan response report
GAP_REPORT_TYPE_SCAN_RSP_EXT,
/// Legacy scan response report
GAP_REPORT_TYPE_SCAN_RSP_LEG,
/// Periodic advertising report
GAP_REPORT_TYPE_PER_ADV,
};
/// Advertising properties bit field bit value
enum gap_adv_prop
{
/// Indicate that advertising is connectable, reception of CONNECT_REQ or AUX_CONNECT_REQ
/// PDUs is accepted. Not applicable for periodic advertising.
GAP_ADV_PROP_CONNECTABLE_BIT = (1 << 0),
/// Indicate that advertising is scannable, reception of SCAN_REQ or AUX_SCAN_REQ PDUs is
/// accepted
GAP_ADV_PROP_SCANNABLE_BIT = (1 << 1),
/// Indicate that advertising targets a specific device. Only apply in following cases:
/// - Legacy advertising: if connectable
/// - Extended advertising: connectable or (non connectable and non discoverable)
GAP_ADV_PROP_DIRECTED_BIT = (1 << 2),
/// Indicate that High Duty Cycle has to be used for advertising on primary channel
/// Apply only if created advertising is not an extended advertising
GAP_ADV_PROP_HDC_BIT = (1 << 3),
/// Bit 4 is reserved
GAP_ADV_PROP_RESERVED_4_BIT = (1 << 4),
/// Enable anonymous mode. Device address won't appear in send PDUs
/// Valid only if created advertising is an extended advertising
GAP_ADV_PROP_ANONYMOUS_BIT = (1 << 5),
/// Include TX Power in the extended header of the advertising PDU.
/// Valid only if created advertising is not a legacy advertising
GAP_ADV_PROP_TX_PWR_BIT = (1 << 6),
/// Include TX Power in the periodic advertising PDU.
/// Valid only if created advertising is a periodic advertising
GAP_ADV_PROP_PER_TX_PWR_BIT = (1 << 7),
/// Indicate if application must be informed about received scan requests PDUs
GAP_ADV_PROP_SCAN_REQ_NTF_EN_BIT = (1 << 8),
};
/// PHY Type
enum gap_phy_type
{
/// LE 1M
GAP_PHY_TYPE_LE_1M = 0,
/// LE 2M
GAP_PHY_TYPE_LE_2M,
/// LE Coded
GAP_PHY_TYPE_LE_CODED,
};
/// Advertising discovery mode
enum gap_adv_disc_mode
{
/// Mode in non-discoverable
GAP_ADV_MODE_NON_DISC = 0,
/// Mode in general discoverable
GAP_ADV_MODE_GEN_DISC,
/// Mode in limited discoverable
GAP_ADV_MODE_LIM_DISC,
};
/// Scanning Types
enum gap_scan_type
{
/// General discovery
GAP_SCAN_TYPE_GEN_DISC = 0,
/// Limited discovery
GAP_SCAN_TYPE_LIM_DISC,
/// Observer
GAP_SCAN_TYPE_OBSERVER,
/// Selective observer
GAP_SCAN_TYPE_SEL_OBSERVER,
/// Connectable discovery
GAP_SCAN_TYPE_CONN_DISC,
/// Selective connectable discovery
GAP_SCAN_TYPE_SEL_CONN_DISC,
};
/// Scanning properties bit field bit value
enum gap_scan_prop
{
/// Scan advertisement on the LE 1M PHY
GAP_SCAN_PROP_PHY_1M_BIT = (1 << 0),
/// Scan advertisement on the LE Coded PHY
GAP_SCAN_PROP_PHY_CODED_BIT = (1 << 1),
/// Active scan on LE 1M PHY (Scan Request PDUs may be sent)
GAP_SCAN_PROP_ACTIVE_1M_BIT = (1 << 2),
/// Active scan on LE Coded PHY (Scan Request PDUs may be sent)
GAP_SCAN_PROP_ACTIVE_CODED_BIT = (1 << 3),
/// Accept directed advertising packets if we use a RPA and target address cannot be solved by the
/// controller
GAP_SCAN_PROP_ACCEPT_RPA_BIT = (1 << 4),
/// Filter truncated advertising or scan response reports
GAP_SCAN_PROP_FILT_TRUNC_BIT = (1 << 5),
};
/// Initiating Types
enum gap_init_type
{
/// Direct connection establishment, establish a connection with an indicated device
GAPM_INIT_TYPE_DIRECT_CONN_EST = 0,
/// Automatic connection establishment, establish a connection with all devices whose address is
/// present in the white list
GAPM_INIT_TYPE_AUTO_CONN_EST,
/// Name discovery, Establish a connection with an indicated device in order to read content of its
/// Device Name characteristic. Connection is closed once this operation is stopped.
GAPM_INIT_TYPE_NAME_DISC,
};
/// Initiating Properties
enum gap_init_prop
{
/// Scan connectable advertisements on the LE 1M PHY. Connection parameters for the LE 1M PHY are provided
GAPM_INIT_PROP_1M_BIT = (1 << 0),
/// Connection parameters for the LE 2M PHY are provided
GAPM_INIT_PROP_2M_BIT = (1 << 1),
/// Scan connectable advertisements on the LE Coded PHY. Connection parameters for the LE Coded PHY are provided
GAPM_INIT_PROP_CODED_BIT = (1 << 2),
};
/// Advertising report information
enum gap_adv_report_info
{
/// Report Type
GAP_REPORT_INFO_REPORT_TYPE = 0x07,
/// Report is complete
GAP_REPORT_INFO_COMPLETE = (1 << 3),
/// Connectable advertising
GAP_REPORT_INFO_CONN_ADV = (1 << 4),
/// Scannable advertising
GAP_REPORT_INFO_SCAN_ADV = (1 << 5),
/// Directed advertising
GAP_REPORT_INFO_DIR_ADV = (1 << 6),
};
/// Filtering policy for duplicated packets
enum gap_dup_filter_pol
{
/// Disable filtering of duplicated packets
GAP_DUP_FILT_DIS = 0,
/// Enable filtering of duplicated packets
GAP_DUP_FILT_EN,
/// Enable filtering of duplicated packets, reset for each scan period
GAP_DUP_FILT_EN_PERIOD,
};
/*
* Masks for advertising properties
****************************************************************************************
*/
/// Advertising properties configurations for legacy advertising
enum gap_leg_adv_prop
{
/// Non connectable non scannable advertising
GAP_ADV_PROP_NON_CONN_NON_SCAN_MASK = 0x0000,
/// Broadcast non scannable advertising - Discovery mode must be Non Discoverable
GAP_ADV_PROP_BROADCAST_NON_SCAN_MASK = GAP_ADV_PROP_NON_CONN_NON_SCAN_MASK,
/// Non connectable scannable advertising
GAP_ADV_PROP_NON_CONN_SCAN_MASK = GAP_ADV_PROP_SCANNABLE_BIT,
/// Broadcast non scannable advertising - Discovery mode must be Non Discoverable
GAP_ADV_PROP_BROADCAST_SCAN_MASK = GAP_ADV_PROP_NON_CONN_SCAN_MASK,
/// Undirected connectable advertising
GAP_ADV_PROP_UNDIR_CONN_MASK = GAP_ADV_PROP_CONNECTABLE_BIT | GAP_ADV_PROP_SCANNABLE_BIT,
/// Directed connectable advertising
GAP_ADV_PROP_DIR_CONN_MASK = GAP_ADV_PROP_DIRECTED_BIT | GAP_ADV_PROP_CONNECTABLE_BIT,
/// Directed connectable with Low Duty Cycle
GAP_ADV_PROP_DIR_CONN_LDC_MASK = GAP_ADV_PROP_DIR_CONN_MASK,
/// Directed connectable with High Duty Cycle
GAP_ADV_PROP_DIR_CONN_HDC_MASK = GAP_ADV_PROP_DIR_CONN_MASK | GAP_ADV_PROP_HDC_BIT,
};
/// Advertising properties configurations for extended advertising
enum gap_ext_adv_prop
{
/// Non connectable non scannable extended advertising
GAP_EXT_ADV_PROP_NON_CONN_NON_SCAN_MASK = 0x0000,
/// Non connectable scannable extended advertising
GAP_EXT_ADV_PROP_NON_CONN_SCAN_MASK = GAP_ADV_PROP_SCANNABLE_BIT,
/// Undirected connectable extended advertising
GAP_EXT_ADV_PROP_UNDIR_CONN_MASK = GAP_ADV_PROP_CONNECTABLE_BIT,
/// Directed connectable extended advertising
GAP_EXT_ADV_PROP_DIR_CONN_MASK = GAP_ADV_PROP_CONNECTABLE_BIT | GAP_ADV_PROP_DIRECTED_BIT,
};
/*************** GAP Structures ********************/
/// Device name
struct gap_dev_name
{
/// name length
uint16_t length;
/// name value
uint8_t value[__ARRAY_EMPTY];
};
/// Slave preferred connection parameters
struct gap_slv_pref
{
/// Connection interval minimum
uint16_t con_intv_min;
/// Connection interval maximum
uint16_t con_intv_max;
/// Slave latency
uint16_t slave_latency;
/// Connection supervision timeout multiplier
uint16_t conn_timeout;
};
///BD Address structure
#define BLE_BD_ADDR_T
typedef struct
{
///6-byte array address value
uint8_t addr[GAP_BD_ADDR_LEN];
} bd_addr_t;
///Channel map structure
typedef struct
{
///5-byte channel map array
uint8_t map[GAP_LE_CHNL_MAP_LEN];
} le_chnl_map_t;
///Random number structure
typedef struct
{
///8-byte array for random number
uint8_t nb[GAP_RAND_NB_LEN];
} rand_nb_t;
///Advertising report structure
typedef struct
{
///Event type:
/// - ADV_CONN_UNDIR: Connectable Undirected advertising
/// - ADV_CONN_DIR: Connectable directed advertising
/// - ADV_DISC_UNDIR: Discoverable undirected advertising
/// - ADV_NONCONN_UNDIR: Non-connectable undirected advertising
uint8_t evt_type;
///Advertising address type: public/random
uint8_t adv_addr_type;
///Advertising address value
bd_addr_t adv_addr;
///Data length in advertising packet
uint8_t data_len;
///Data of advertising packet
uint8_t data[GAP_ADV_DATA_LEN];
///RSSI value for advertising packet
uint8_t rssi;
} adv_report_t;
/// P256 Public key data format
typedef struct
{
/// X Coordinate of the key
uint8_t x[GAP_P256_KEY_LEN];
/// X Coordinate of the key
uint8_t y[GAP_P256_KEY_LEN];
} public_key_t;
/// P256 private key data format
typedef struct
{
///MSB->LSB
uint8_t Secrt_key[GAP_P256_KEY_LEN];
} private_key_t;
/// Address information about a device address
struct gap_bdaddr
{
/// BD Address of device
bd_addr_t addr;
/// Address type of the device 0=public/1=private random
uint8_t addr_type;
};
/// Resolving list device information
struct gap_ral_dev_info
{
/// Address type of the device 0=public/1=private random
uint8_t addr_type;
/// BD Address of device
bd_addr_t addr;
/// Peer IRK
uint8_t peer_irk[GAP_KEY_LEN];
/// Local IRK
uint8_t local_irk[GAP_KEY_LEN];
};
/// Generic Security key structure
struct gap_sec_key
{
/// Key value MSB -> LSB
uint8_t key[GAP_KEY_LEN];
};
/// Configuration for advertising on primary channel
struct gap_adv_prim_cfg
{
/// Minimum advertising interval (in unit of 625us). Must be greater than 20ms
uint32_t adv_intv_min;
/// Maximum advertising interval (in unit of 625us). Must be greater than 20ms
uint32_t adv_intv_max;
/// Bit field indicating the channel mapping
uint8_t chnl_map;
/// Indicate on which PHY primary advertising has to be performed (@see enum gap_phy_type)
/// Note that LE 2M PHY is not allowed and that legacy advertising only support LE 1M PHY
uint8_t phy;
};
/// Configuration for advertising on secondary channel
struct gap_adv_second_cfg
{
/// 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
uint8_t max_skip;
/// Indicate on which PHY secondary advertising has to be performed (@see enum gap_phy_type)
uint8_t phy;
/// Advertising SID
uint8_t adv_sid;
};
/// Configuration for periodic advertising
struct gap_adv_period_cfg
{
/// Minimum advertising interval (in unit of 1.25ms). Must be greater than 20ms
uint16_t adv_intv_min;
/// Maximum advertising interval (in unit of 1.25ms). Must be greater than 20ms
uint16_t adv_intv_max;
};
/// Advertising parameters
struct gap_adv_param
{
/// Advertising type (@see enum gap_adv_type)
uint8_t type;
/// Discovery mode (@see enum gap_adv_mode)
uint8_t disc_mode;
/// Bit field value provided advertising properties (@see enum gap_adv_prop for bit signification)
uint16_t prop;
/// Maximum power level at which the advertising packets have to be transmitted
/// (between -127 and 126 dBm)
int8_t max_tx_pwr;
/// Advertising filtering policy
uint8_t filter_pol;
/// Peer address configuration (only used in case of directed advertising)
struct gap_bdaddr peer_addr;
/// Configuration for primary advertising
struct gap_adv_prim_cfg prim_cfg;
/// Configuration for secondary advertising (valid only if advertising type is
/// GAPM_ADV_TYPE_EXTENDED or GAPM_ADV_TYPE_PERIODIC)
struct gap_adv_second_cfg second_cfg;
/// Configuration for periodic advertising (valid only if advertising type os
/// GAPM_ADV_TYPE_PERIODIC)
struct gap_adv_period_cfg period_cfg;
};
/// Additional advertising parameters
struct gap_adv_add_param
{
/// Advertising duration (in unit of 10ms). 0 means that advertising continues
/// until the host disable it
uint16_t duration;
/// Maximum number of extended advertising events the controller shall attempt to send prior to
/// terminating the extending advertising
/// Valid only if extended advertising
uint8_t max_adv_evt;
};
/// Scan Window operation parameters
struct gap_scan_wd_op_param
{
/// Scan interval
uint16_t scan_intv;
/// Scan window
uint16_t scan_wd;
};
/// Scanning parameters
struct gap_scan_param
{
/// Type of scanning to be started (@see enum gap_scan_type)
uint8_t type;
/// Properties for the scan procedure (@see enum gap_scan_prop for bit signification)
uint8_t prop;
/// Duplicate packet filtering policy
uint8_t dup_filt_pol;
/// Reserved for future use
uint8_t rsvd;
/// Scan window opening parameters for LE 1M PHY
struct gap_scan_wd_op_param scan_param_1m;
/// Scan window opening parameters for LE Coded PHY
struct gap_scan_wd_op_param scan_param_coded;
/// Scan duration (in unit of 10ms). 0 means that the controller will scan continuously until
/// reception of a stop command from the application
uint16_t duration;
/// Scan period (in unit of 1.28s). Time interval betweem two consequent starts of a scan duration
/// by the controller. 0 means that the scan procedure is not periodic
uint16_t period;
};
/// Connection parameters
struct gap_conn_param
{
/// Minimum value for the connection interval (in unit of 1.25ms). Shall be less than or equal to
/// conn_intv_max value. Allowed range is 7.5ms to 4s.
uint16_t conn_intv_min;
/// Maximum value for the connection interval (in unit of 1.25ms). Shall be greater than or equal to
/// conn_intv_min value. Allowed range is 7.5ms to 4s.
uint16_t conn_intv_max;
/// Slave latency. Number of events that can be missed by a connected slave device
uint16_t conn_latency;
/// Link supervision timeout (in unit of 10ms). Allowed range is 100ms to 32s
uint16_t supervision_to;
/// Recommended minimum duration of connection events (in unit of 625us)
uint16_t ce_len_min;
/// Recommended maximum duration of connection events (in unit of 625us)
uint16_t ce_len_max;
};
/// Initiating parameters
struct gap_init_param
{
/// Initiating type (@see enum gap_init_type)
uint8_t type;
/// Properties for the initiating procedure (@see enum gap_init_prop for bit signification)
uint8_t prop;
/// Timeout for automatic connection establishment (in unit of 10ms). Cancel the procedure if not all
/// indicated devices have been connected when the timeout occurs. 0 means there is no timeout
uint16_t conn_to;
/// Scan window opening parameters for LE 1M PHY
struct gap_scan_wd_op_param scan_param_1m;
/// Scan window opening parameters for LE Coded PHY
struct gap_scan_wd_op_param scan_param_coded;
/// Connection parameters for LE 1M PHY
struct gap_conn_param conn_param_1m;
/// Connection parameters for LE 2M PHY
struct gap_conn_param conn_param_2m;
/// Connection parameters for LE Coded PHY
struct gap_conn_param conn_param_coded;
/// Address of peer device in case white list is not used for connection
struct gap_bdaddr peer_addr;
};
/// Periodic advertising information
struct gap_period_adv_addr_cfg
{
/// Advertiser address information
struct gap_bdaddr addr;
/// Advertising SID
uint8_t adv_sid;
};
/// Periodic synchronization parameters
struct gap_period_sync_param
{
/// Number of periodic advertising that can be skipped after a successful receive. Maximum authorized
/// value is 499
uint16_t skip;
/// Synchronization timeout for the periodic advertising (in unit of 10ms between 100ms and 163.84s)
uint16_t sync_to;
/// Indicate if Periodic Advertiser List has to be used to determine which advertiser to listen to, else
/// provided advertiser information are used
uint8_t use_pal;
/// Reserved for future used
uint8_t rsvd;
/// Address of advertiser with which synchronization has to be established (used only if use_pal is false)
struct gap_period_adv_addr_cfg adv_addr;
};
/// @} GAP
#endif // GAP_H_
Reference in New Issue View Git Blame Copy Permalink