Events.h

00001 /* mbed Microcontroller Library
00002  * Copyright (c) 2018-2018 ARM Limited
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015 */
00016 
00017 #ifndef BLE_GAP_EVENTS_H
00018 #define BLE_GAP_EVENTS_H
00019 
00020 #include "ble/blecommon.h"
00021 #include "ble/BLETypes.h"
00022 
00023 namespace ble {
00024 
00025 /**
00026  * @addtogroup ble
00027  * @{
00028  * @addtogroup gap
00029  * @{
00030  */
00031 
00032 /**
00033  * Event generated when an advertising packet is seen during passive scanning
00034  * or a scan response is received during active scanning.
00035  *
00036  * @see ble::Gap::EventHandler::onPeriodicAdvertisingReport()
00037  */
00038 struct AdvertisingReportEvent {
00039 #if !defined(DOXYGEN_ONLY)
00040 
00041     /** Create an advertising report event.
00042      *
00043      * @param type Type of advertising used.
00044      * @param peerAddressType Peer address type of advertiser.
00045      * @param peerAddress Peer address of advertiser.
00046      * @param primaryPhy PHY used on the primary channels.
00047      * @param secondaryPhy PHY used on secondary channels.
00048      * @param SID Set identification number.
00049      * @param txPower Transmission power reported by the packet.
00050      * @param rssi Measured signal strength.
00051      * @param periodicInterval Interval of periodic advertising.
00052      * @param directAddressType Directed advertising target address type.
00053      * @param directAddress Directed advertising target address.
00054      * @param advertisingData Advertising payload.
00055      */
00056     AdvertisingReportEvent(
00057         const advertising_event_t &type,
00058         const peer_address_type_t &peerAddressType,
00059         const address_t &peerAddress,
00060         const phy_t &primaryPhy,
00061         const phy_t &secondaryPhy,
00062         advertising_sid_t SID,
00063         advertising_power_t txPower,
00064         rssi_t rssi,
00065         uint16_t periodicInterval,
00066         const peer_address_type_t &directAddressType,
00067         const address_t &directAddress,
00068         const mbed::Span<const uint8_t>  &advertisingData
00069     ) :
00070         type(type),
00071         peerAddressType(peerAddressType),
00072         peerAddress(peerAddress),
00073         primaryPhy(primaryPhy),
00074         secondaryPhy(secondaryPhy),
00075         SID(SID),
00076         txPower(txPower),
00077         rssi(rssi),
00078         periodicInterval(periodicInterval),
00079         directAddressType(directAddressType),
00080         directAddress(directAddress),
00081         advertisingData(advertisingData)
00082     {
00083     }
00084 
00085 #endif
00086 
00087     /** Get event type. */
00088     const advertising_event_t &getType() const
00089     {
00090         return type;
00091     }
00092 
00093     /** Get peer address type. */
00094     const peer_address_type_t &getPeerAddressType() const
00095     {
00096         return peerAddressType;
00097     }
00098 
00099     /** Get peer address. */
00100     const address_t &getPeerAddress() const
00101     {
00102         return peerAddress;
00103     }
00104 
00105     /** Get primary PHY. */
00106     const phy_t &getPrimaryPhy() const
00107     {
00108         return primaryPhy;
00109     }
00110 
00111     /** Get secondary PHY. */
00112     const phy_t &getSecondaryPhy() const
00113     {
00114         return secondaryPhy;
00115     }
00116 
00117     /** Get advertising set identifier. */
00118     advertising_sid_t getSID() const
00119     {
00120         return SID;
00121     }
00122 
00123     /** Get TX power. */
00124     advertising_power_t getTxPower() const
00125     {
00126         return txPower;
00127     }
00128 
00129     /** Get received signal strength. */
00130     rssi_t getRssi() const
00131     {
00132         return rssi;
00133     }
00134 
00135     /** Indicate if periodic interval is valid */
00136     bool isPeriodicIntervalPresent() const {
00137         return periodicInterval != 0;
00138     }
00139 
00140     /** Get interval. */
00141     periodic_interval_t getPeriodicInterval() const
00142     {
00143         return periodic_interval_t(periodicInterval);
00144     }
00145 
00146     /** Get target address type in directed advertising. */
00147     const peer_address_type_t &getDirectAddressType() const
00148     {
00149         return directAddressType;
00150     }
00151 
00152     /** Get target address in directed advertising. */
00153     const address_t &getDirectAddress() const
00154     {
00155         return directAddress;
00156     }
00157 
00158     /** Get payload. */
00159     const mbed::Span<const uint8_t>  &getPayload() const
00160     {
00161         return advertisingData;
00162     }
00163 
00164 private:
00165     advertising_event_t type;
00166     peer_address_type_t peerAddressType;
00167     address_t const &peerAddress;
00168     phy_t primaryPhy;
00169     phy_t secondaryPhy;
00170     advertising_sid_t SID;
00171     advertising_power_t txPower;
00172     rssi_t rssi;
00173     uint16_t periodicInterval;
00174     peer_address_type_t directAddressType;
00175     const address_t &directAddress;
00176     mbed::Span<const uint8_t>  advertisingData;
00177 };
00178 
00179 /**
00180  * Event generated when a connection initiation ends (successfully or not).
00181  *
00182  * @see ble::Gap::EventHandler::onConnectionComplete().
00183  */
00184 struct ConnectionCompleteEvent {
00185 #if !defined(DOXYGEN_ONLY)
00186 
00187     /** Create a connection complete event.
00188      *
00189      * @param success BLE_ERROR_NONE if connection succeeded.
00190      * @param connectionHandle Connection handle if successful.
00191      * @param ownRole Role of the local device.
00192      * @param peerAddressType Peer address type.
00193      * @param peerAddress Peer address.
00194      * @param localResolvablePrivateAddress Local address type if privacy enabled.
00195      * @param peerResolvablePrivateAddress Peer address type if privacy enabled.
00196      * @param connectionInterval Connection interval.
00197      * @param connectionLatency Connection latency in events.
00198      * @param supervisionTimeout Supervision timeout.
00199      * @param masterClockAccuracy Peer clock accuracy in parts per million.
00200      */
00201     ConnectionCompleteEvent(
00202         ble_error_t status,
00203         connection_handle_t connectionHandle,
00204         connection_role_t ownRole,
00205         const peer_address_type_t &peerAddressType,
00206         const address_t &peerAddress,
00207         const address_t &localResolvablePrivateAddress,
00208         const address_t &peerResolvablePrivateAddress,
00209         conn_interval_t  connectionInterval,
00210         slave_latency_t  connectionLatency,
00211         supervision_timeout_t  supervisionTimeout,
00212         uint16_t masterClockAccuracy
00213     ) :
00214         status(status),
00215         connectionHandle(connectionHandle),
00216         ownRole(ownRole),
00217         peerAddressType(peerAddressType),
00218         peerAddress(peerAddress),
00219         localResolvablePrivateAddress(localResolvablePrivateAddress),
00220         peerResolvablePrivateAddress(peerResolvablePrivateAddress),
00221         connectionInterval(connectionInterval),
00222         connectionLatency(connectionLatency),
00223         supervisionTimeout(supervisionTimeout),
00224         masterClockAccuracy(masterClockAccuracy)
00225     {
00226     }
00227 
00228 #endif
00229 
00230     /** Get connection complete event status. */
00231     ble_error_t getStatus() const
00232     {
00233         return status;
00234     }
00235 
00236     /** Get connection handle (valid only when successful). */
00237     connection_handle_t getConnectionHandle() const
00238     {
00239         return connectionHandle;
00240     }
00241 
00242     /** Get own role. */
00243     connection_role_t getOwnRole() const
00244     {
00245         return ownRole;
00246     }
00247 
00248     /** Get peer address type. */
00249     const peer_address_type_t &getPeerAddressType() const
00250     {
00251         return peerAddressType;
00252     }
00253 
00254     /** Get peer address. */
00255     const address_t &getPeerAddress() const
00256     {
00257         return peerAddress;
00258     }
00259 
00260     /** Get get local resolvable random address if privacy is used. */
00261     const address_t &getLocalResolvablePrivateAddress() const
00262     {
00263         return localResolvablePrivateAddress;
00264     }
00265 
00266     /** Get peer resolvable private address if privacy is used. */
00267     const address_t &getPeerResolvablePrivateAddress() const
00268     {
00269         return peerResolvablePrivateAddress;
00270     }
00271 
00272     /** Get connection interval. */
00273     conn_interval_t  getConnectionInterval() const
00274     {
00275         return connectionInterval;
00276     }
00277 
00278     /** Get connection latency. */
00279     slave_latency_t  getConnectionLatency() const
00280     {
00281         return connectionLatency;
00282     }
00283 
00284     /** Get supervision timeout. */
00285     supervision_timeout_t  getSupervisionTimeout() const
00286     {
00287         return supervisionTimeout;
00288     }
00289 
00290     /** Get clock accuracy in parts per million. */
00291     uint16_t getMasterClockAccuracy() const
00292     {
00293         return masterClockAccuracy;
00294     }
00295 
00296 private:
00297     ble_error_t status;
00298     connection_handle_t connectionHandle;
00299     connection_role_t ownRole;
00300     peer_address_type_t peerAddressType;
00301     const address_t &peerAddress;
00302     const address_t &localResolvablePrivateAddress;
00303     const address_t &peerResolvablePrivateAddress;
00304     conn_interval_t  connectionInterval;
00305     slave_latency_t  connectionLatency;
00306     supervision_timeout_t  supervisionTimeout;
00307     uint16_t masterClockAccuracy;
00308 };
00309 
00310 /**
00311  * Event generated when you first receive a periodic advertisement.
00312  *
00313  * @see ble::Gap::EventHandler::onPeriodicAdvertisingSyncEstablished().
00314  */
00315 struct PeriodicAdvertisingSyncEstablishedEvent {
00316 #if !defined(DOXYGEN_ONLY)
00317 
00318     /** Create advertising sync event.
00319      *
00320      * @param success BLE_ERROR_NONE if synchronisation was achieved.
00321      * @param syncHandle Advertising sync handle.
00322      * @param sid Advertising set identifier.
00323      * @param peerAddressType Peer address type.
00324      * @param peerAddress Peer address.
00325      * @param peerPhy PHY used for advertisements.
00326      * @param advertisingInterval Periodic advertising interval.
00327      * @param masterClockAccuracy Peer clock accuracy in parts per million.
00328      */
00329     PeriodicAdvertisingSyncEstablishedEvent(
00330         ble_error_t status,
00331         periodic_sync_handle_t syncHandle,
00332         advertising_sid_t sid,
00333         const peer_address_type_t &peerAddressType,
00334         const address_t &peerAddress,
00335         const phy_t &peerPhy,
00336         uint16_t advertisingInterval,
00337         const clock_accuracy_t &peerClockAccuracy
00338     ) :
00339         status(status),
00340         syncHandle(syncHandle),
00341         sid(sid),
00342         peerAddressType(peerAddressType),
00343         peerAddress(peerAddress),
00344         peerPhy(peerPhy),
00345         advertisingInterval(advertisingInterval),
00346         peerClockAccuracy(peerClockAccuracy)
00347     {
00348     }
00349 
00350 #endif
00351 
00352     /** Get sync establishment status. */
00353     ble_error_t getStatus() const
00354     {
00355         return status;
00356     }
00357 
00358     /** Get periodic advertising sync handle. */
00359     periodic_sync_handle_t getSyncHandle() const
00360     {
00361         return syncHandle;
00362     }
00363 
00364     /** Get advertising set identifier. */
00365     advertising_sid_t getSid() const
00366     {
00367         return sid;
00368     }
00369 
00370     /** Get peer address type. */
00371     const peer_address_type_t &getPeerAddressType() const
00372     {
00373         return peerAddressType;
00374     }
00375 
00376     /** Get peer address. */
00377     const address_t &getPeerAddress() const
00378     {
00379         return peerAddress;
00380     }
00381 
00382     /** Get PHY used. */
00383     const phy_t &getPeerPhy() const
00384     {
00385         return peerPhy;
00386     }
00387 
00388     /** Get interval. */
00389     uint16_t getAdvertisingInterval() const
00390     {
00391         return advertisingInterval;
00392     }
00393 
00394     /** Get clock accuracy in parts per million. */
00395     const clock_accuracy_t &getPeerClockAccuracy() const
00396     {
00397         return peerClockAccuracy;
00398     }
00399 
00400 private:
00401     ble_error_t status;
00402     periodic_sync_handle_t syncHandle;
00403     advertising_sid_t sid;
00404     peer_address_type_t peerAddressType;
00405     const address_t &peerAddress;
00406     phy_t peerPhy;
00407     uint16_t advertisingInterval;
00408     clock_accuracy_t peerClockAccuracy;
00409 };
00410 
00411 /**
00412  * Event generated when periodic advertising packet is received.
00413  *
00414  * @see ble::Gap::EventHandler::onPeriodicAdvertisingReport().
00415  */
00416 struct PeriodicAdvertisingReportEvent {
00417 #if !defined(DOXYGEN_ONLY)
00418 
00419     /** Create periodic advertising report event.
00420      *
00421      * @param syncHandle Periodic advertising sync handle
00422      * @param txPower TX power.
00423      * @param rssi Received signal strength.
00424      * @param dataStatus Status to indicate the completeness of the payload.
00425      * @param payload Periodic advertisement payload.
00426      */
00427     PeriodicAdvertisingReportEvent(
00428         periodic_sync_handle_t syncHandle,
00429         advertising_power_t txPower,
00430         rssi_t rssi,
00431         advertising_data_status_t dataStatus,
00432         const mbed::Span<const uint8_t>  &payload
00433     ) :
00434         syncHandle(syncHandle),
00435         txPower(txPower),
00436         rssi(rssi),
00437         dataStatus(dataStatus),
00438         payload(payload)
00439     {
00440     }
00441 
00442 #endif
00443 
00444     /** Get periodic advertising sync handle. */
00445     periodic_sync_handle_t getSyncHandle() const
00446     {
00447         return syncHandle;
00448     }
00449 
00450     /** Get TX power as reported by the advertising packet. */
00451     advertising_power_t getTxPower() const
00452     {
00453         return txPower;
00454     }
00455 
00456     /** Get received signal strength. */
00457     rssi_t getRssi() const
00458     {
00459         return rssi;
00460     }
00461 
00462     /** Get data completeness status. */
00463     const advertising_data_status_t &getDataStatus() const
00464     {
00465         return dataStatus;
00466     }
00467 
00468     /** Get payload. */
00469     const mbed::Span<const uint8_t>  &getPayload() const
00470     {
00471         return payload;
00472     }
00473 
00474 private:
00475     periodic_sync_handle_t syncHandle;
00476     advertising_power_t txPower;
00477     rssi_t rssi;
00478     advertising_data_status_t dataStatus;
00479     mbed::Span<const uint8_t>  payload;
00480 };
00481 
00482 /**
00483  * Event generated when periodic advertising sync is lost.
00484  *
00485  * @see ble::Gap::EventHandler::onPeriodicAdvertisingSyncLoss().
00486  */
00487 struct PeriodicAdvertisingSyncLoss {
00488 #if !defined(DOXYGEN_ONLY)
00489 
00490     /** Create periodic advertising sync loss event.
00491      *
00492      * @param syncHandle Periodic advertising sync handle.
00493      */
00494     PeriodicAdvertisingSyncLoss(
00495         periodic_sync_handle_t syncHandle
00496     ) :
00497         syncHandle(syncHandle)
00498     {
00499     }
00500 
00501 #endif
00502 
00503     /** Get periodic sync handle. */
00504     periodic_sync_handle_t getSyncHandle() const
00505     {
00506         return syncHandle;
00507     }
00508 
00509 private:
00510     periodic_sync_handle_t syncHandle;
00511 };
00512 
00513 /**
00514  * Event generated when scan times out.
00515  *
00516  * @see ble::Gap::EventHandler::onScanTimeout().
00517  */
00518 struct ScanTimeoutEvent { };
00519 
00520 /**
00521  * Event produced when advertising ends.
00522  *
00523  * @see ble::Gap::EventHandler::onAdvertisingEnd().
00524  */
00525 struct AdvertisingEndEvent {
00526 #if !defined(DOXYGEN_ONLY)
00527 
00528     /** Create advertising end event.
00529      *
00530      * @param advHandle Advertising set handle.
00531      * @param connection Connection handle.
00532      * @param completed_events Number of events created during before advertising end.
00533      * @param connected True if connection has been established.
00534      */
00535     AdvertisingEndEvent(
00536         advertising_handle_t advHandle,
00537         connection_handle_t connection,
00538         uint8_t completed_events,
00539         bool connected
00540     ) :
00541         advHandle(advHandle),
00542         connection(connection),
00543         completed_events(completed_events),
00544         connected(connected)
00545     {
00546     }
00547 
00548 #endif
00549 
00550     /** Get advertising handle. */
00551     advertising_handle_t getAdvHandle() const
00552     {
00553         return advHandle;
00554     }
00555 
00556     /** Get connection handle (valid only if connected successfully). */
00557     connection_handle_t getConnection() const
00558     {
00559         return connection;
00560     }
00561 
00562     /** Get how many events advertising created. */
00563     uint8_t getCompleted_events() const
00564     {
00565         return completed_events;
00566     }
00567 
00568     /** Has the advertising ended with a connection. */
00569     bool isConnected() const
00570     {
00571         return connected;
00572     }
00573 
00574 private:
00575     advertising_handle_t advHandle;
00576     connection_handle_t connection;
00577     uint8_t completed_events;
00578     bool connected;
00579 };
00580 
00581 /**
00582  * Event produced when a peer requests a scan response from the advertiser.
00583  *
00584  * @see ble::Gap::EventHandler::onScanRequestReceived().
00585  */
00586 struct ScanRequestEvent {
00587 #if !defined(DOXYGEN_ONLY)
00588 
00589     /** Create scan request event.
00590      *
00591      * @param advHandle Advertising handle.
00592      * @param peerAddressType Peer address type.
00593      * @param peerAddress Peer address.
00594      */
00595     ScanRequestEvent(
00596         advertising_handle_t advHandle,
00597         const peer_address_type_t &peerAddressType,
00598         const address_t &peerAddress
00599     ) :
00600         advHandle(advHandle),
00601         peerAddressType(peerAddressType),
00602         peerAddress(peerAddress)
00603     {
00604     }
00605 
00606 #endif
00607 
00608     /** Get advertising handle. */
00609     advertising_handle_t getAdvHandle() const
00610     {
00611         return advHandle;
00612     }
00613 
00614     /** Get peer address type. */
00615     const peer_address_type_t &getPeerAddressType() const
00616     {
00617         return peerAddressType;
00618     }
00619 
00620     /** Get peer address. */
00621     const address_t &getPeerAddress() const
00622     {
00623         return peerAddress;
00624     }
00625 
00626 private:
00627     advertising_handle_t advHandle;
00628     peer_address_type_t peerAddressType;
00629     const address_t &peerAddress;
00630 };
00631 
00632 /**
00633  * Event produced when a disconnection is complete.
00634  *
00635  * @see ble::Gap::EventHandler::onDisconnectionComplete().
00636  */
00637 struct DisconnectionCompleteEvent {
00638 #if !defined(DOXYGEN_ONLY)
00639 
00640     DisconnectionCompleteEvent(
00641         connection_handle_t connectionHandle,
00642         const disconnection_reason_t &reason
00643     ) :
00644         connectionHandle(connectionHandle), reason(reason)
00645     {
00646     }
00647 
00648 #endif
00649 
00650     /**
00651      * Get the handle of the connection that has expired.
00652      */
00653     connection_handle_t getConnectionHandle() const
00654     {
00655         return connectionHandle;
00656     }
00657 
00658     /**
00659      * Get the reason of the disconnection.
00660      */
00661     const disconnection_reason_t &getReason() const
00662     {
00663         return reason;
00664     }
00665 
00666 private:
00667     ble::connection_handle_t connectionHandle;
00668     ble::disconnection_reason_t reason;
00669 };
00670 
00671 /**
00672  * Event received when a peer wants to change the connection parameters.
00673  *
00674  * @see ble::Gap::EventHandler::onUpdateConnectionParametersRequest().
00675  */
00676 struct UpdateConnectionParametersRequestEvent {
00677 #if !defined(DOXYGEN_ONLY)
00678 
00679     UpdateConnectionParametersRequestEvent(
00680         connection_handle_t connectionHandle,
00681         const conn_interval_t  &minConnectionInterval,
00682         const conn_interval_t  &maxConnectionInterval,
00683         const slave_latency_t  &slaveLatency,
00684         const supervision_timeout_t  &supervision_timeout
00685     ) :
00686         connectionHandle(connectionHandle),
00687         minConnectionInterval(minConnectionInterval),
00688         maxConnectionInterval(maxConnectionInterval),
00689         slaveLatency(slaveLatency),
00690         supervisionTimeout(supervision_timeout)
00691     {
00692     }
00693 
00694 #endif
00695 
00696     /**
00697      * Get the connection handle.
00698      */
00699     connection_handle_t getConnectionHandle() const
00700     {
00701         return connectionHandle;
00702     }
00703 
00704     /**
00705      * Get the minimum connection interval requested.
00706      */
00707     const conn_interval_t  &getMinConnectionInterval() const
00708     {
00709         return minConnectionInterval;
00710     }
00711 
00712     /**
00713      * Get the maximum connection interval requested.
00714      */
00715     const conn_interval_t  &getMaxConnectionInterval() const
00716     {
00717         return maxConnectionInterval;
00718     }
00719 
00720     /**
00721      * Get the slave latency requested.
00722      */
00723     const slave_latency_t  &getSlaveLatency() const
00724     {
00725         return slaveLatency;
00726     }
00727 
00728     /**
00729      * Get the supervision timeout requested.
00730      */
00731     const supervision_timeout_t  &getSupervisionTimeout() const
00732     {
00733         return supervisionTimeout;
00734     }
00735 
00736 private:
00737     ble::connection_handle_t connectionHandle;
00738     ble::conn_interval_t  minConnectionInterval;
00739     ble::conn_interval_t  maxConnectionInterval;
00740     ble::slave_latency_t  slaveLatency;
00741     ble::supervision_timeout_t  supervisionTimeout;
00742 };
00743 
00744 /**
00745  * Event received when connection parameters have been updated.
00746  *
00747  * @see ble::Gap::EventHandler::onConnectionParametersUpdateComplete().
00748  */
00749 struct ConnectionParametersUpdateCompleteEvent {
00750 #if !defined(DOXYGEN_ONLY)
00751 
00752     ConnectionParametersUpdateCompleteEvent(
00753         ble_error_t status,
00754         connection_handle_t connectionHandle,
00755         const conn_interval_t  &connectionInterval,
00756         const slave_latency_t  &slaveLatency,
00757         const supervision_timeout_t  &supervisionTimeout
00758     ) :
00759         status(status),
00760         connectionHandle(connectionHandle),
00761         connectionInterval(connectionInterval),
00762         slaveLatency(slaveLatency),
00763         supervisionTimeout(supervisionTimeout)
00764     {
00765     }
00766 
00767 #endif
00768 
00769     /**
00770      * Get the status of the operation. It is equal to BLE_ERROR_NONE in case of
00771      * success.
00772      */
00773     ble_error_t getStatus() const
00774     {
00775         return status;
00776     }
00777 
00778     /**
00779      * Get the handle of the connection that has been updated.
00780      */
00781     connection_handle_t getConnectionHandle() const
00782     {
00783         return connectionHandle;
00784     }
00785 
00786     /**
00787      * Get the new connection interval.
00788      */
00789     const conn_interval_t  &getConnectionInterval() const
00790     {
00791         return connectionInterval;
00792     }
00793 
00794     /**
00795      * Get the new slave latency.
00796      */
00797     const slave_latency_t  &getSlaveLatency() const
00798     {
00799         return slaveLatency;
00800     }
00801 
00802     /**
00803      * Get the new supervision timeout.
00804      */
00805     const supervision_timeout_t  &getSupervisionTimeout() const
00806     {
00807         return supervisionTimeout;
00808     }
00809 
00810 private:
00811     ble_error_t status;
00812     ble::connection_handle_t connectionHandle;
00813     ble::conn_interval_t  connectionInterval;
00814     ble::slave_latency_t  slaveLatency;
00815     ble::supervision_timeout_t  supervisionTimeout;
00816 
00817 };
00818 
00819 /**
00820  * @}
00821  * @}
00822  */
00823 
00824 } // namespace ble
00825 
00826 #endif //BLE_GAP_EVENTS_H