Scott Jenson / Mbed 2 deprecated BLE_EddystoneBeaconConfigService_Button

Button initiated config service

Dependencies:   BLE_API_EddystoneConfigService_2 mbed nRF51822

Fork of BLE_EddystoneBeaconConfigService_3 by URIBeacon

EddystoneConfigService.h@48:992874158d56, 2015-09-12 (annotated)

Committer:
mbedAustin
Date:
Sat Sep 12 11:04:20 2015 +0000
Revision:
48:992874158d56
Parent:
47:c191b7b7521d
Child:
49:8214ca32b038
fixed tx transmit issue where it was transmitting the index when it was supposed to transmit the value at that index.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbedAustin 23:05e9bb3b13af 1 /* mbed Microcontroller Library
mbedAustin 23:05e9bb3b13af 2 * Copyright (c) 2006-2013 ARM Limited
mbedAustin 23:05e9bb3b13af 3 *
mbedAustin 23:05e9bb3b13af 4 * Licensed under the Apache License, Version 2.0 (the "License");
mbedAustin 23:05e9bb3b13af 5 * you may not use this file except in compliance with the License.
mbedAustin 23:05e9bb3b13af 6 * You may obtain a copy of the License at
mbedAustin 23:05e9bb3b13af 7 *
mbedAustin 23:05e9bb3b13af 8 * http://www.apache.org/licenses/LICENSE-2.0
mbedAustin 23:05e9bb3b13af 9 *
mbedAustin 23:05e9bb3b13af 10 * Unless required by applicable law or agreed to in writing, software
mbedAustin 23:05e9bb3b13af 11 * distributed under the License is distributed on an "AS IS" BASIS,
mbedAustin 23:05e9bb3b13af 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
mbedAustin 23:05e9bb3b13af 13 * See the License for the specific language governing permissions and
mbedAustin 23:05e9bb3b13af 14 * limitations under the License.
mbedAustin 23:05e9bb3b13af 15 */
mbedAustin 23:05e9bb3b13af 16
mbedAustin 33:8c65879e7d52 17 #ifndef SERVICES_EDDYSTONEBEACONCONFIGSERVICE_H_
mbedAustin 33:8c65879e7d52 18 #define SERVICES_EDDYSTONEBEACONCONFIGSERVICE_H_
mbedAustin 23:05e9bb3b13af 19
mbedAustin 23:05e9bb3b13af 20 #include "mbed.h"
mbedAustin 23:05e9bb3b13af 21 #include "ble/BLE.h"
mbedAustin 34:5876fbb1aa62 22 #include "ble/services/EddystoneService.h"
mbedAustin 23:05e9bb3b13af 23
mbedAustin 33:8c65879e7d52 24 #define EDDYSTONE_NUM_UID_FRAMES 10
mbedAustin 33:8c65879e7d52 25 #define EDDYSTONE_NUM_URL_FRAMES 50
mbedAustin 33:8c65879e7d52 26
mbedAustin 23:05e9bb3b13af 27
mbedAustin 23:05e9bb3b13af 28 #define UUID_URI_BEACON(FIRST, SECOND) { \
mbedAustin 23:05e9bb3b13af 29 0xee, 0x0c, FIRST, SECOND, 0x87, 0x86, 0x40, 0xba, \
mbedAustin 23:05e9bb3b13af 30 0xab, 0x96, 0x99, 0xb9, 0x1a, 0xc9, 0x81, 0xd8, \
mbedAustin 23:05e9bb3b13af 31 }
mbedAustin 23:05e9bb3b13af 32
mbedAustin 23:05e9bb3b13af 33 static const uint8_t UUID_URI_BEACON_SERVICE[] = UUID_URI_BEACON(0x20, 0x80);
mbedAustin 23:05e9bb3b13af 34 static const uint8_t UUID_LOCK_STATE_CHAR[] = UUID_URI_BEACON(0x20, 0x81);
mbedAustin 23:05e9bb3b13af 35 static const uint8_t UUID_LOCK_CHAR[] = UUID_URI_BEACON(0x20, 0x82);
mbedAustin 23:05e9bb3b13af 36 static const uint8_t UUID_UNLOCK_CHAR[] = UUID_URI_BEACON(0x20, 0x83);
mbedAustin 23:05e9bb3b13af 37 static const uint8_t UUID_URI_DATA_CHAR[] = UUID_URI_BEACON(0x20, 0x84);
mbedAustin 23:05e9bb3b13af 38 static const uint8_t UUID_FLAGS_CHAR[] = UUID_URI_BEACON(0x20, 0x85);
mbedAustin 23:05e9bb3b13af 39 static const uint8_t UUID_ADV_POWER_LEVELS_CHAR[] = UUID_URI_BEACON(0x20, 0x86);
mbedAustin 23:05e9bb3b13af 40 static const uint8_t UUID_TX_POWER_MODE_CHAR[] = UUID_URI_BEACON(0x20, 0x87);
mbedAustin 23:05e9bb3b13af 41 static const uint8_t UUID_BEACON_PERIOD_CHAR[] = UUID_URI_BEACON(0x20, 0x88);
mbedAustin 23:05e9bb3b13af 42 static const uint8_t UUID_RESET_CHAR[] = UUID_URI_BEACON(0x20, 0x89);
mbedAustin 34:5876fbb1aa62 43 extern const uint8_t BEACON_EDDYSTONE[2];
mbedAustin 23:05e9bb3b13af 44
mbedAustin 23:05e9bb3b13af 45 /**
mbedAustin 23:05e9bb3b13af 46 * @class EddystoneConfigService
mbedAustin 23:05e9bb3b13af 47 * @brief Eddystone Configuration Service. Can be used to set URL, adjust power levels, and set flags.
mbedAustin 25:e20bed9e466f 48 * See https://github.com/google/eddystone
mbedAustin 23:05e9bb3b13af 49 *
mbedAustin 23:05e9bb3b13af 50 */
mbedAustin 23:05e9bb3b13af 51 class EddystoneConfigService
mbedAustin 23:05e9bb3b13af 52 {
mbedAustin 39:2c73bc1ff4f5 53 public:
mbedAustin 23:05e9bb3b13af 54 /**
mbedAustin 23:05e9bb3b13af 55 * @brief Transmission Power Modes for UriBeacon
mbedAustin 23:05e9bb3b13af 56 */
mbedAustin 23:05e9bb3b13af 57 static const uint8_t TX_POWER_MODE_LOWEST = 0; /*!< Lowest TX power mode */
mbedAustin 23:05e9bb3b13af 58 static const uint8_t TX_POWER_MODE_LOW = 1; /*!< Low TX power mode */
mbedAustin 23:05e9bb3b13af 59 static const uint8_t TX_POWER_MODE_MEDIUM = 2; /*!< Medium TX power mode */
mbedAustin 23:05e9bb3b13af 60 static const uint8_t TX_POWER_MODE_HIGH = 3; /*!< High TX power mode */
mbedAustin 34:5876fbb1aa62 61 static const unsigned NUM_POWER_MODES = 4; /*!< Number of Power Modes defined */
mbedAustin 23:05e9bb3b13af 62
mbedAustin 23:05e9bb3b13af 63 static const int ADVERTISING_INTERVAL_MSEC = 1000; // Advertising interval for config service.
mbedAustin 23:05e9bb3b13af 64 static const int SERVICE_DATA_MAX = 31; // Maximum size of service data in ADV packets
mbedAustin 23:05e9bb3b13af 65
mbedAustin 23:05e9bb3b13af 66 typedef uint8_t Lock_t[16]; /* 128 bits */
mbedAustin 23:05e9bb3b13af 67 typedef int8_t PowerLevels_t[NUM_POWER_MODES];
mbedAustin 23:05e9bb3b13af 68
mbedAustin 23:05e9bb3b13af 69 // There are currently 3 subframes defined, URI, UID, and TLM
mbedAustin 23:05e9bb3b13af 70 #define EDDYSTONE_MAX_FRAMETYPE 3
mbedAustin 23:05e9bb3b13af 71 void (*frames[EDDYSTONE_MAX_FRAMETYPE])(uint8_t *, uint32_t);
mbedAustin 23:05e9bb3b13af 72 uint8_t frameIndex;
mbedAustin 23:05e9bb3b13af 73 static const int URI_DATA_MAX = 18;
mbedAustin 23:05e9bb3b13af 74 typedef uint8_t UriData_t[URI_DATA_MAX];
mbedAustin 23:05e9bb3b13af 75
mbedAustin 23:05e9bb3b13af 76 // UID Frame Type subfields
mbedAustin 23:05e9bb3b13af 77 static const int UID_NAMESPACEID_SIZE = 10;
mbedAustin 37:22175faa76be 78 typedef uint8_t UIDNamespaceID_t[UID_NAMESPACEID_SIZE];
mbedAustin 23:05e9bb3b13af 79 static const int UID_INSTANCEID_SIZE = 6;
mbedAustin 37:22175faa76be 80 typedef uint8_t UIDInstanceID_t[UID_INSTANCEID_SIZE];
mbedAustin 23:05e9bb3b13af 81
mbedAustin 23:05e9bb3b13af 82 // Eddystone Frame Type ID
mbedAustin 23:05e9bb3b13af 83 static const uint8_t FRAME_TYPE_UID = 0x00;
mbedAustin 23:05e9bb3b13af 84 static const uint8_t FRAME_TYPE_URL = 0x10;
mbedAustin 23:05e9bb3b13af 85 static const uint8_t FRAME_TYPE_TLM = 0x20;
mbedAustin 23:05e9bb3b13af 86
mbedAustin 23:05e9bb3b13af 87 static const uint8_t FRAME_SIZE_TLM = 14; // TLM frame is a constant 14Bytes
mbedAustin 23:05e9bb3b13af 88 static const uint8_t FRAME_SIZE_UID = 20; // includes RFU bytes
mbedAustin 23:05e9bb3b13af 89
mbedAustin 23:05e9bb3b13af 90 struct Params_t {
mbedAustin 39:2c73bc1ff4f5 91 // Config Data
mbedAustin 39:2c73bc1ff4f5 92 bool isConfigured; // Flag for configuration being complete, True = configured, false = not configured. Reset at instantiation, used for external callbacks.
mbedAustin 34:5876fbb1aa62 93 uint8_t lockedState;
mbedAustin 23:05e9bb3b13af 94 Lock_t lock;
mbedAustin 23:05e9bb3b13af 95 uint8_t flags;
mbedAustin 23:05e9bb3b13af 96 PowerLevels_t advPowerLevels; // Current value of AdvertisedPowerLevels
mbedAustin 23:05e9bb3b13af 97 uint8_t txPowerMode; // Firmware power levels used with setTxPower()
mbedAustin 23:05e9bb3b13af 98 uint16_t beaconPeriod;
mbedAustin 39:2c73bc1ff4f5 99 // TLM Frame Data
mbedAustin 34:5876fbb1aa62 100 uint8_t tlmVersion; // version of TLM packet
mbedAustin 39:2c73bc1ff4f5 101 bool tlmEnabled;
mbedAustin 39:2c73bc1ff4f5 102 uint8_t tlmBeaconPeriod; // how often to broadcat TLM frame, in minutes.
mbedAustin 39:2c73bc1ff4f5 103 // URI Frame Data
mbedAustin 39:2c73bc1ff4f5 104 uint8_t uriDataLength;
mbedAustin 39:2c73bc1ff4f5 105 UriData_t uriData;
mbedAustin 39:2c73bc1ff4f5 106 bool uriEnabled;
mbedAustin 39:2c73bc1ff4f5 107 uint8_t uriBeaconPeriod; // how often to broadcast URIFrame, in # of adv frames
mbedAustin 39:2c73bc1ff4f5 108 // UID Frame Data
mbedAustin 34:5876fbb1aa62 109 UIDNamespaceID_t uidNamespaceID; // UUID type, Namespace ID, 10B
mbedAustin 34:5876fbb1aa62 110 UIDInstanceID_t uidInstanceID; // UUID type, Instance ID, 6B
mbedAustin 39:2c73bc1ff4f5 111 bool uidEnabled;
mbedAustin 39:2c73bc1ff4f5 112 uint8_t uidBeaconPeriod; // how often to broadcast UID Frame, in # of adv frames
mbedAustin 23:05e9bb3b13af 113 };
mbedAustin 23:05e9bb3b13af 114
mbedAustin 23:05e9bb3b13af 115 /**
mbedAustin 23:05e9bb3b13af 116 * @param[ref] ble
mbedAustin 23:05e9bb3b13af 117 * BLEDevice object for the underlying controller.
mbedAustin 23:05e9bb3b13af 118 * @param[in/out] paramsIn
mbedAustin 23:05e9bb3b13af 119 * Reference to application-visible beacon state, loaded
mbedAustin 23:05e9bb3b13af 120 * from persistent storage at startup.
mbedAustin 23:05e9bb3b13af 121 * @param[in] defaultAdvPowerLevelsIn
mbedAustin 23:05e9bb3b13af 122 * Default power-levels array; applies only if the resetToDefaultsFlag is true.
mbedAustin 23:05e9bb3b13af 123 */
mbedAustin 23:05e9bb3b13af 124 EddystoneConfigService(BLEDevice &bleIn,
mbedAustin 23:05e9bb3b13af 125 Params_t &paramsIn,
mbedAustin 44:0e27ee7800b8 126 PowerLevels_t &defaultAdvPowerLevelsIn) :
mbedAustin 23:05e9bb3b13af 127 ble(bleIn),
mbedAustin 31:11e7a505a4be 128 params(paramsIn), // Initialize URL Data
mbedAustin 45:1827e4f496a7 129 defaultUriDataLength(0),
mbedAustin 23:05e9bb3b13af 130 defaultUriData(),
mbedAustin 34:5876fbb1aa62 131 defaultUidNamespaceID(), // Initialize UID Data
mbedAustin 34:5876fbb1aa62 132 defaultUidInstanceID(),
mbedAustin 47:c191b7b7521d 133 defaultUrlPower(defaultAdvPowerLevelsIn[params.txPowerMode]),
mbedAustin 47:c191b7b7521d 134 defaultUidPower(defaultAdvPowerLevelsIn[params.txPowerMode]),
mbedAustin 23:05e9bb3b13af 135 defaultAdvPowerLevels(defaultAdvPowerLevelsIn),
mbedAustin 23:05e9bb3b13af 136 initSucceeded(false),
mbedAustin 23:05e9bb3b13af 137 resetFlag(),
mbedAustin 44:0e27ee7800b8 138 tlmIsSet(false),
mbedAustin 44:0e27ee7800b8 139 urlIsSet(false),
mbedAustin 44:0e27ee7800b8 140 uidIsSet(false),
mbedAustin 34:5876fbb1aa62 141 lockedStateChar(UUID_LOCK_STATE_CHAR, &params.lockedState),
mbedAustin 23:05e9bb3b13af 142 lockChar(UUID_LOCK_CHAR, &params.lock),
mbedAustin 23:05e9bb3b13af 143 uriDataChar(UUID_URI_DATA_CHAR, params.uriData, 0, URI_DATA_MAX,
mbedAustin 23:05e9bb3b13af 144 GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE),
mbedAustin 23:05e9bb3b13af 145 unlockChar(UUID_UNLOCK_CHAR, &params.lock),
mbedAustin 23:05e9bb3b13af 146 flagsChar(UUID_FLAGS_CHAR, &params.flags),
mbedAustin 23:05e9bb3b13af 147 advPowerLevelsChar(UUID_ADV_POWER_LEVELS_CHAR, &params.advPowerLevels),
mbedAustin 23:05e9bb3b13af 148 txPowerModeChar(UUID_TX_POWER_MODE_CHAR, &params.txPowerMode),
mbedAustin 23:05e9bb3b13af 149 beaconPeriodChar(UUID_BEACON_PERIOD_CHAR, &params.beaconPeriod),
mbedAustin 31:11e7a505a4be 150 resetChar(UUID_RESET_CHAR, &resetFlag)
mbedAustin 31:11e7a505a4be 151 {
mbedAustin 44:0e27ee7800b8 152 // set eddystone as not configured yet. Used to exit config before timeout if GATT services are written to.
mbedAustin 40:6f39aee31205 153 params.isConfigured = false;
mbedAustin 44:0e27ee7800b8 154 }
mbedAustin 44:0e27ee7800b8 155
mbedAustin 44:0e27ee7800b8 156 /*
mbedAustin 44:0e27ee7800b8 157 * @breif Start EddystoneConfig advertising. This function should be called after the EddystoneConfig constructor and after all the frames have been added.
mbedAustin 44:0e27ee7800b8 158 * @paramsP[in] resetToDefaultsFlag
mbedAustin 44:0e27ee7800b8 159 * Applies to the state of the 'paramsIn' parameter.
mbedAustin 44:0e27ee7800b8 160 * If true, it indicates that paramsIn is potentially
mbedAustin 44:0e27ee7800b8 161 * un-initialized, and default values should be used
mbedAustin 44:0e27ee7800b8 162 * instead. Otherwise, paramsIn overrides the defaults.
mbedAustin 44:0e27ee7800b8 163 *
mbedAustin 44:0e27ee7800b8 164 */
mbedAustin 44:0e27ee7800b8 165 void start(bool resetToDefaultsFlag){
mbedAustin 46:46bb40f60816 166 printf("reset to defaults flag = %d\r\n", resetToDefaultsFlag);
mbedAustin 23:05e9bb3b13af 167 if (!resetToDefaultsFlag && (params.uriDataLength > URI_DATA_MAX)) {
mbedAustin 23:05e9bb3b13af 168 resetToDefaultsFlag = true;
mbedAustin 23:05e9bb3b13af 169 }
mbedAustin 23:05e9bb3b13af 170 if (resetToDefaultsFlag) {
mbedAustin 23:05e9bb3b13af 171 resetToDefaults();
mbedAustin 23:05e9bb3b13af 172 } else {
mbedAustin 23:05e9bb3b13af 173 updateCharacteristicValues();
mbedAustin 23:05e9bb3b13af 174 }
mbedAustin 23:05e9bb3b13af 175
mbedAustin 23:05e9bb3b13af 176 lockChar.setWriteAuthorizationCallback(this, &EddystoneConfigService::lockAuthorizationCallback);
mbedAustin 23:05e9bb3b13af 177 unlockChar.setWriteAuthorizationCallback(this, &EddystoneConfigService::unlockAuthorizationCallback);
mbedAustin 23:05e9bb3b13af 178 uriDataChar.setWriteAuthorizationCallback(this, &EddystoneConfigService::uriDataWriteAuthorizationCallback);
mbedAustin 23:05e9bb3b13af 179 flagsChar.setWriteAuthorizationCallback(this, &EddystoneConfigService::basicAuthorizationCallback<uint8_t>);
mbedAustin 23:05e9bb3b13af 180 advPowerLevelsChar.setWriteAuthorizationCallback(this, &EddystoneConfigService::basicAuthorizationCallback<PowerLevels_t>);
mbedAustin 23:05e9bb3b13af 181 txPowerModeChar.setWriteAuthorizationCallback(this, &EddystoneConfigService::powerModeAuthorizationCallback);
mbedAustin 23:05e9bb3b13af 182 beaconPeriodChar.setWriteAuthorizationCallback(this, &EddystoneConfigService::basicAuthorizationCallback<uint16_t>);
mbedAustin 23:05e9bb3b13af 183 resetChar.setWriteAuthorizationCallback(this, &EddystoneConfigService::basicAuthorizationCallback<uint8_t>);
mbedAustin 23:05e9bb3b13af 184
mbedAustin 23:05e9bb3b13af 185 static GattCharacteristic *charTable[] = {
mbedAustin 23:05e9bb3b13af 186 &lockedStateChar, &lockChar, &unlockChar, &uriDataChar,
mbedAustin 23:05e9bb3b13af 187 &flagsChar, &advPowerLevelsChar, &txPowerModeChar, &beaconPeriodChar, &resetChar
mbedAustin 23:05e9bb3b13af 188 };
mbedAustin 23:05e9bb3b13af 189
mbedAustin 23:05e9bb3b13af 190 GattService configService(UUID_URI_BEACON_SERVICE, charTable, sizeof(charTable) / sizeof(GattCharacteristic *));
mbedAustin 23:05e9bb3b13af 191
mbedAustin 23:05e9bb3b13af 192 ble.addService(configService);
mbedAustin 23:05e9bb3b13af 193 ble.onDataWritten(this, &EddystoneConfigService::onDataWrittenCallback);
mbedAustin 23:05e9bb3b13af 194
mbedAustin 23:05e9bb3b13af 195 setupEddystoneConfigAdvertisements(); /* Setup advertising for the configService. */
mbedAustin 23:05e9bb3b13af 196
mbedAustin 23:05e9bb3b13af 197 initSucceeded = true;
mbedAustin 23:05e9bb3b13af 198 }
mbedAustin 23:05e9bb3b13af 199
mbedAustin 39:2c73bc1ff4f5 200 /*
mbedAustin 39:2c73bc1ff4f5 201 * Check if eddystone initialized successfully
mbedAustin 39:2c73bc1ff4f5 202 */
mbedAustin 39:2c73bc1ff4f5 203 bool initSuccessfully(void) const {
mbedAustin 23:05e9bb3b13af 204 return initSucceeded;
mbedAustin 23:05e9bb3b13af 205 }
mbedAustin 44:0e27ee7800b8 206
mbedAustin 44:0e27ee7800b8 207 /*
mbedAustin 44:0e27ee7800b8 208 * @breif Function to update the default values for the TLM frame. Only applied if Reset Defaults is applied.
mbedAustin 44:0e27ee7800b8 209 *
mbedAustin 44:0e27ee7800b8 210 * @param[in] tlmVersionIn Version of the TLM frame being used
mbedAustin 44:0e27ee7800b8 211 * @param[in] advPeriodInMin how long between TLM frames being advertised, this is measured in minutes.
mbedAustin 44:0e27ee7800b8 212 *
mbedAustin 44:0e27ee7800b8 213 */
mbedAustin 44:0e27ee7800b8 214 void setDefaultTLMFrameData(uint8_t tlmVersionIn = 0, uint32_t advPeriodInMin = 1){
mbedAustin 44:0e27ee7800b8 215 DBG("Setting Default TLM Data, version = %d, advPeriodInMind= %d",tlmVersionIn,advPeriodInMin);
mbedAustin 44:0e27ee7800b8 216 defaultTlmVersion = tlmVersionIn;
mbedAustin 44:0e27ee7800b8 217 TlmBatteryVoltage = 0;
mbedAustin 44:0e27ee7800b8 218 TlmBeaconTemp = 0;
mbedAustin 44:0e27ee7800b8 219 TlmPduCount = 0;
mbedAustin 44:0e27ee7800b8 220 TlmTimeSinceBoot = 0;
mbedAustin 44:0e27ee7800b8 221 defaultTlmAdvPeriod = advPeriodInMin;
mbedAustin 44:0e27ee7800b8 222 tlmIsSet = true; // flag to add this to eddystone service when config is done
mbedAustin 44:0e27ee7800b8 223
mbedAustin 44:0e27ee7800b8 224 }
mbedAustin 44:0e27ee7800b8 225
mbedAustin 44:0e27ee7800b8 226 /*
mbedAustin 44:0e27ee7800b8 227 * @breif Function to update the default values for the URI frame. Only applied if Reset Defaults is applied.
mbedAustin 44:0e27ee7800b8 228 *
mbedAustin 44:0e27ee7800b8 229 * @param[in] uriIn url to advertise
mbedAustin 44:0e27ee7800b8 230 * @param[in] advPeriod how long to advertise the url for, measured in number of ADV frames.
mbedAustin 44:0e27ee7800b8 231 *
mbedAustin 44:0e27ee7800b8 232 */
mbedAustin 44:0e27ee7800b8 233 void setDefaultURIFrameData(const char * uriIn,uint32_t advPeriod = 1000){
mbedAustin 44:0e27ee7800b8 234 DBG("Setting Default URI Data");
mbedAustin 45:1827e4f496a7 235 // // Set URL Frame
mbedAustin 45:1827e4f496a7 236 // EddystoneService::encodeURL(uriIn, defaultUriData, defaultUriDataLength); // encode URL to URL Formatting
mbedAustin 45:1827e4f496a7 237 // if (defaultUriDataLength > URI_DATA_MAX) {
mbedAustin 45:1827e4f496a7 238 // return;
mbedAustin 45:1827e4f496a7 239 // }
mbedAustin 45:1827e4f496a7 240 memcpy(defaultUriData,uriIn,URI_DATA_MAX);
mbedAustin 45:1827e4f496a7 241 // defaultUriData = (UriData_t *)uriIn;
mbedAustin 44:0e27ee7800b8 242 defaultUriAdvPeriod = advPeriod;
mbedAustin 44:0e27ee7800b8 243 urlIsSet = true; // flag to add this to eddystone service when config is done
mbedAustin 44:0e27ee7800b8 244 }
mbedAustin 44:0e27ee7800b8 245
mbedAustin 44:0e27ee7800b8 246 /*
mbedAustin 44:0e27ee7800b8 247 * @breif Function to update the default values for the UID frame. Only applied if Reset Defaults is applied.
mbedAustin 44:0e27ee7800b8 248 *
mbedAustin 44:0e27ee7800b8 249 * @param[in] namespaceID 10Byte Namespace ID
mbedAustin 44:0e27ee7800b8 250 * @param[in] instanceID 6Byte Instance ID
mbedAustin 44:0e27ee7800b8 251 * @param[in] advPeriod how long to advertise the URL for, measured in the number of adv frames.
mbedAustin 44:0e27ee7800b8 252 *
mbedAustin 44:0e27ee7800b8 253 */
mbedAustin 44:0e27ee7800b8 254 void setDefaultUIDFrameData(UIDNamespaceID_t *namespaceID, UIDInstanceID_t *instanceID, uint32_t advPeriod = 10){
mbedAustin 44:0e27ee7800b8 255 //Set UID frame
mbedAustin 44:0e27ee7800b8 256 DBG("Setting default UID Data");
mbedAustin 44:0e27ee7800b8 257 memcpy(defaultUidNamespaceID, namespaceID, UID_NAMESPACEID_SIZE);
mbedAustin 44:0e27ee7800b8 258 memcpy(defaultUidInstanceID, instanceID, UID_INSTANCEID_SIZE);
mbedAustin 44:0e27ee7800b8 259 defaultUidAdvPeriod = advPeriod;
mbedAustin 44:0e27ee7800b8 260 uidIsSet = true; // flag to add this to eddystone service when config is done
mbedAustin 44:0e27ee7800b8 261 }
mbedAustin 23:05e9bb3b13af 262
mbedAustin 23:05e9bb3b13af 263 /* Start out by advertising the configService for a limited time after
mbedAustin 23:05e9bb3b13af 264 * startup; and switch to the normal non-connectible beacon functionality
mbedAustin 23:05e9bb3b13af 265 * afterwards. */
mbedAustin 23:05e9bb3b13af 266 void setupEddystoneConfigAdvertisements() {
mbedAustin 23:05e9bb3b13af 267 const char DEVICE_NAME[] = "eddystone Config";
mbedAustin 23:05e9bb3b13af 268
mbedAustin 23:05e9bb3b13af 269 ble.clearAdvertisingPayload();
mbedAustin 23:05e9bb3b13af 270
mbedAustin 23:05e9bb3b13af 271 ble.accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
mbedAustin 23:05e9bb3b13af 272
mbedAustin 23:05e9bb3b13af 273 // UUID is in different order in the ADV frame (!)
mbedAustin 23:05e9bb3b13af 274 uint8_t reversedServiceUUID[sizeof(UUID_URI_BEACON_SERVICE)];
mbedAustin 23:05e9bb3b13af 275 for (unsigned int i = 0; i < sizeof(UUID_URI_BEACON_SERVICE); i++) {
mbedAustin 23:05e9bb3b13af 276 reversedServiceUUID[i] = UUID_URI_BEACON_SERVICE[sizeof(UUID_URI_BEACON_SERVICE) - i - 1];
mbedAustin 23:05e9bb3b13af 277 }
mbedAustin 23:05e9bb3b13af 278 ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS, reversedServiceUUID, sizeof(reversedServiceUUID));
mbedAustin 23:05e9bb3b13af 279 ble.accumulateAdvertisingPayload(GapAdvertisingData::GENERIC_TAG);
mbedAustin 23:05e9bb3b13af 280 ble.accumulateScanResponse(GapAdvertisingData::COMPLETE_LOCAL_NAME, reinterpret_cast<const uint8_t *>(&DEVICE_NAME), sizeof(DEVICE_NAME));
mbedAustin 23:05e9bb3b13af 281 ble.accumulateScanResponse(
mbedAustin 23:05e9bb3b13af 282 GapAdvertisingData::TX_POWER_LEVEL,
mbedAustin 23:05e9bb3b13af 283 reinterpret_cast<uint8_t *>(&defaultAdvPowerLevels[EddystoneConfigService::TX_POWER_MODE_LOW]),
mbedAustin 23:05e9bb3b13af 284 sizeof(uint8_t));
mbedAustin 23:05e9bb3b13af 285
mbedAustin 23:05e9bb3b13af 286 ble.setTxPower(params.advPowerLevels[params.txPowerMode]);
mbedAustin 23:05e9bb3b13af 287 ble.setDeviceName(reinterpret_cast<const uint8_t *>(&DEVICE_NAME));
mbedAustin 23:05e9bb3b13af 288 ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
mbedAustin 34:5876fbb1aa62 289 ble.setAdvertisingInterval(GapAdvertisingParams::MSEC_TO_ADVERTISEMENT_DURATION_UNITS(ADVERTISING_INTERVAL_MSEC));
mbedAustin 23:05e9bb3b13af 290 }
mbedAustin 23:05e9bb3b13af 291
mbedAustin 23:05e9bb3b13af 292 /*
mbedAustin 25:e20bed9e466f 293 * This function actually impliments the Eddystone Beacon service. It can be called with the help of the wrapper function
mbedAustin 25:e20bed9e466f 294 * to load saved config params, or it can be called explicitly to reset the eddystone beacon to hardcoded values on each reset.
mbedAustin 25:e20bed9e466f 295 *
mbedAustin 25:e20bed9e466f 296 */
mbedAustin 23:05e9bb3b13af 297 void setupEddystoneAdvertisements() {
mbedAustin 23:05e9bb3b13af 298 DBG("Switching Config -> adv");
mbedAustin 44:0e27ee7800b8 299 // Save params to storage
mbedAustin 23:05e9bb3b13af 300 extern void saveURIBeaconConfigParams(const Params_t *paramsP); /* forward declaration; necessary to avoid a circular dependency. */
mbedAustin 23:05e9bb3b13af 301 saveURIBeaconConfigParams(&params);
mbedAustin 44:0e27ee7800b8 302 // Setup Eddystone Service
mbedAustin 47:c191b7b7521d 303 static EddystoneService eddyServ(ble,params.beaconPeriod,params.advPowerLevels[params.txPowerMode]);
mbedAustin 44:0e27ee7800b8 304 // Set configured frames (TLM,UID,URI...etc)
mbedAustin 43:e4a4f9a8766f 305 if(params.tlmEnabled){
mbedAustin 43:e4a4f9a8766f 306 eddyServ.setTLMFrameData(params.tlmVersion,params.tlmBeaconPeriod);
mbedAustin 43:e4a4f9a8766f 307 }
mbedAustin 43:e4a4f9a8766f 308 if(params.uriEnabled){
mbedAustin 48:992874158d56 309 eddyServ.setURLFrameData(params.advPowerLevels[params.txPowerMode], (const char *) params.uriData, params.uriBeaconPeriod);
mbedAustin 43:e4a4f9a8766f 310 }
mbedAustin 43:e4a4f9a8766f 311 if(params.uidEnabled){
mbedAustin 48:992874158d56 312 eddyServ.setUIDFrameData(params.advPowerLevels[params.txPowerMode], (uint8_t *) params.uidNamespaceID, (uint8_t *) params.uidInstanceID, params.uidBeaconPeriod);
mbedAustin 43:e4a4f9a8766f 313 }
mbedAustin 43:e4a4f9a8766f 314 // Start Advertising the eddystone service.
mbedAustin 43:e4a4f9a8766f 315 eddyServ.start();
mbedAustin 23:05e9bb3b13af 316 }
mbedAustin 23:05e9bb3b13af 317
mbedAustin 23:05e9bb3b13af 318 private:
mbedAustin 23:05e9bb3b13af 319
mbedAustin 23:05e9bb3b13af 320 /*
mbedAustin 23:05e9bb3b13af 321 * This callback is invoked when a GATT client attempts to modify any of the
mbedAustin 23:05e9bb3b13af 322 * characteristics of this service. Attempts to do so are also applied to
mbedAustin 23:05e9bb3b13af 323 * the internal state of this service object.
mbedAustin 23:05e9bb3b13af 324 */
mbedAustin 23:05e9bb3b13af 325 void onDataWrittenCallback(const GattWriteCallbackParams *writeParams) {
mbedAustin 23:05e9bb3b13af 326 uint16_t handle = writeParams->handle;
mbedAustin 23:05e9bb3b13af 327
mbedAustin 23:05e9bb3b13af 328 if (handle == lockChar.getValueHandle()) {
mbedAustin 23:05e9bb3b13af 329 // Validated earlier
mbedAustin 23:05e9bb3b13af 330 memcpy(params.lock, writeParams->data, sizeof(Lock_t));
roywant 38:8fdb16f67e7c 331 // Set the state to be locked by the lock code (note: zeros are a valid lock)
mbedAustin 34:5876fbb1aa62 332 params.lockedState = true;
mbedAustin 44:0e27ee7800b8 333 INFO("Device Locked");
mbedAustin 23:05e9bb3b13af 334 } else if (handle == unlockChar.getValueHandle()) {
mbedAustin 23:05e9bb3b13af 335 // Validated earlier
mbedAustin 34:5876fbb1aa62 336 params.lockedState = false;
mbedAustin 44:0e27ee7800b8 337 INFO("Device Unlocked");
mbedAustin 23:05e9bb3b13af 338 } else if (handle == uriDataChar.getValueHandle()) {
mbedAustin 23:05e9bb3b13af 339 params.uriDataLength = writeParams->len;
mbedAustin 45:1827e4f496a7 340 memset(params.uriData,0x00,URI_DATA_MAX); // clear URI string
mbedAustin 45:1827e4f496a7 341 memcpy(params.uriData, writeParams->data, params.uriDataLength); // set URI string
mbedAustin 44:0e27ee7800b8 342 params.uriEnabled = true;
mbedAustin 34:5876fbb1aa62 343 INFO("URI = %s, URILen = %d", writeParams->data, writeParams->len);
mbedAustin 23:05e9bb3b13af 344 } else if (handle == flagsChar.getValueHandle()) {
mbedAustin 23:05e9bb3b13af 345 params.flags = *(writeParams->data);
mbedAustin 34:5876fbb1aa62 346 INFO("flagsChar = 0x%x",params.flags);
mbedAustin 23:05e9bb3b13af 347 } else if (handle == advPowerLevelsChar.getValueHandle()) {
mbedAustin 23:05e9bb3b13af 348 memcpy(params.advPowerLevels, writeParams->data, sizeof(PowerLevels_t));
mbedAustin 47:c191b7b7521d 349 INFO("PowerLevelsChar = %4x",params.advPowerLevels);
mbedAustin 23:05e9bb3b13af 350 } else if (handle == txPowerModeChar.getValueHandle()) {
mbedAustin 23:05e9bb3b13af 351 params.txPowerMode = *(writeParams->data);
mbedAustin 34:5876fbb1aa62 352 INFO("TxPowerModeChar = %d",params.txPowerMode);
mbedAustin 23:05e9bb3b13af 353 } else if (handle == beaconPeriodChar.getValueHandle()) {
mbedAustin 23:05e9bb3b13af 354 params.beaconPeriod = *((uint16_t *)(writeParams->data));
mbedAustin 44:0e27ee7800b8 355 INFO("BeaconPeriod = %d",params.beaconPeriod);
mbedAustin 23:05e9bb3b13af 356
mbedAustin 23:05e9bb3b13af 357 /* Re-map beaconPeriod to within permissible bounds if necessary. */
mbedAustin 23:05e9bb3b13af 358 if (params.beaconPeriod != 0) {
mbedAustin 23:05e9bb3b13af 359 bool paramsUpdated = false;
mbedAustin 23:05e9bb3b13af 360 if (params.beaconPeriod < ble.getMinAdvertisingInterval()) {
mbedAustin 23:05e9bb3b13af 361 params.beaconPeriod = ble.getMinAdvertisingInterval();
mbedAustin 23:05e9bb3b13af 362 paramsUpdated = true;
mbedAustin 23:05e9bb3b13af 363 } else if (params.beaconPeriod > ble.getMaxAdvertisingInterval()) {
mbedAustin 23:05e9bb3b13af 364 params.beaconPeriod = ble.getMaxAdvertisingInterval();
mbedAustin 23:05e9bb3b13af 365 paramsUpdated = true;
mbedAustin 23:05e9bb3b13af 366 }
mbedAustin 23:05e9bb3b13af 367 if (paramsUpdated) {
mbedAustin 23:05e9bb3b13af 368 ble.updateCharacteristicValue(beaconPeriodChar.getValueHandle(), reinterpret_cast<uint8_t *>(&params.beaconPeriod), sizeof(uint16_t));
mbedAustin 23:05e9bb3b13af 369 }
mbedAustin 23:05e9bb3b13af 370 }
mbedAustin 23:05e9bb3b13af 371 } else if (handle == resetChar.getValueHandle()) {
mbedAustin 46:46bb40f60816 372 INFO("Reset triggered from Config Service, resetting to defaults");
mbedAustin 23:05e9bb3b13af 373 resetToDefaults();
mbedAustin 23:05e9bb3b13af 374 }
roywant 38:8fdb16f67e7c 375 updateCharacteristicValues();
mbedAustin 44:0e27ee7800b8 376 params.isConfigured = true; // some configuration data has been passed, on disconnect switch to advertising mode.
mbedAustin 23:05e9bb3b13af 377 }
mbedAustin 23:05e9bb3b13af 378
mbedAustin 23:05e9bb3b13af 379 /*
mbedAustin 23:05e9bb3b13af 380 * Reset the default values.
mbedAustin 23:05e9bb3b13af 381 */
mbedAustin 23:05e9bb3b13af 382 void resetToDefaults(void) {
mbedAustin 44:0e27ee7800b8 383 INFO("Resetting to defaults");
mbedAustin 44:0e27ee7800b8 384 // General
mbedAustin 34:5876fbb1aa62 385 params.lockedState = false;
mbedAustin 23:05e9bb3b13af 386 memset(params.lock, 0, sizeof(Lock_t));
mbedAustin 34:5876fbb1aa62 387 params.flags = 0x10;
mbedAustin 23:05e9bb3b13af 388 memcpy(params.advPowerLevels, defaultAdvPowerLevels, sizeof(PowerLevels_t));
mbedAustin 23:05e9bb3b13af 389 params.txPowerMode = TX_POWER_MODE_LOW;
mbedAustin 23:05e9bb3b13af 390 params.beaconPeriod = 1000;
mbedAustin 44:0e27ee7800b8 391
mbedAustin 44:0e27ee7800b8 392 // TLM Frame
mbedAustin 44:0e27ee7800b8 393 params.tlmVersion = defaultTlmVersion;
mbedAustin 44:0e27ee7800b8 394 params.tlmBeaconPeriod = defaultTlmAdvPeriod;
mbedAustin 44:0e27ee7800b8 395 params.tlmEnabled = tlmIsSet;
mbedAustin 44:0e27ee7800b8 396
mbedAustin 44:0e27ee7800b8 397 // URL Frame
mbedAustin 44:0e27ee7800b8 398 memcpy(params.uriData, defaultUriData, URI_DATA_MAX);
mbedAustin 44:0e27ee7800b8 399 params.uriDataLength = defaultUriDataLength;
mbedAustin 44:0e27ee7800b8 400 params.uriBeaconPeriod = defaultUriAdvPeriod;
mbedAustin 44:0e27ee7800b8 401 params.uriEnabled = urlIsSet;
mbedAustin 44:0e27ee7800b8 402
mbedAustin 44:0e27ee7800b8 403 // UID Frame
mbedAustin 34:5876fbb1aa62 404 memcpy(params.uidNamespaceID, defaultUidNamespaceID, UID_NAMESPACEID_SIZE);
mbedAustin 34:5876fbb1aa62 405 memcpy(params.uidInstanceID, defaultUidInstanceID, UID_INSTANCEID_SIZE);
mbedAustin 44:0e27ee7800b8 406 params.uidBeaconPeriod = defaultUidAdvPeriod;
mbedAustin 44:0e27ee7800b8 407 params.uidEnabled = uidIsSet;
mbedAustin 44:0e27ee7800b8 408
mbedAustin 23:05e9bb3b13af 409 updateCharacteristicValues();
mbedAustin 23:05e9bb3b13af 410 }
mbedAustin 23:05e9bb3b13af 411
mbedAustin 23:05e9bb3b13af 412 /*
mbedAustin 23:05e9bb3b13af 413 * Internal helper function used to update the GATT database following any
mbedAustin 23:05e9bb3b13af 414 * change to the internal state of the service object.
mbedAustin 23:05e9bb3b13af 415 */
mbedAustin 23:05e9bb3b13af 416 void updateCharacteristicValues(void) {
mbedAustin 34:5876fbb1aa62 417 ble.updateCharacteristicValue(lockedStateChar.getValueHandle(), &params.lockedState, 1);
mbedAustin 23:05e9bb3b13af 418 ble.updateCharacteristicValue(uriDataChar.getValueHandle(), params.uriData, params.uriDataLength);
mbedAustin 23:05e9bb3b13af 419 ble.updateCharacteristicValue(flagsChar.getValueHandle(), &params.flags, 1);
mbedAustin 23:05e9bb3b13af 420 ble.updateCharacteristicValue(beaconPeriodChar.getValueHandle(),
mbedAustin 23:05e9bb3b13af 421 reinterpret_cast<uint8_t *>(&params.beaconPeriod), sizeof(uint16_t));
mbedAustin 23:05e9bb3b13af 422 ble.updateCharacteristicValue(txPowerModeChar.getValueHandle(), &params.txPowerMode, 1);
mbedAustin 23:05e9bb3b13af 423 ble.updateCharacteristicValue(advPowerLevelsChar.getValueHandle(),
mbedAustin 23:05e9bb3b13af 424 reinterpret_cast<uint8_t *>(params.advPowerLevels), sizeof(PowerLevels_t));
mbedAustin 23:05e9bb3b13af 425 }
mbedAustin 23:05e9bb3b13af 426
mbedAustin 23:05e9bb3b13af 427 private:
mbedAustin 23:05e9bb3b13af 428 void lockAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
mbedAustin 34:5876fbb1aa62 429 if (params.lockedState) {
mbedAustin 23:05e9bb3b13af 430 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
mbedAustin 23:05e9bb3b13af 431 } else if (authParams->len != sizeof(Lock_t)) {
mbedAustin 23:05e9bb3b13af 432 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_ATT_VAL_LENGTH;
mbedAustin 23:05e9bb3b13af 433 } else if (authParams->offset != 0) {
mbedAustin 23:05e9bb3b13af 434 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_OFFSET;
mbedAustin 23:05e9bb3b13af 435 } else {
mbedAustin 23:05e9bb3b13af 436 authParams->authorizationReply = AUTH_CALLBACK_REPLY_SUCCESS;
mbedAustin 23:05e9bb3b13af 437 }
mbedAustin 23:05e9bb3b13af 438 }
mbedAustin 23:05e9bb3b13af 439
mbedAustin 23:05e9bb3b13af 440
mbedAustin 23:05e9bb3b13af 441 void unlockAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
mbedAustin 34:5876fbb1aa62 442 if ((!params.lockedState) && (authParams->len == sizeof(Lock_t))) {
mbedAustin 23:05e9bb3b13af 443 authParams->authorizationReply = AUTH_CALLBACK_REPLY_SUCCESS;
mbedAustin 23:05e9bb3b13af 444 } else if (authParams->len != sizeof(Lock_t)) {
mbedAustin 23:05e9bb3b13af 445 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_ATT_VAL_LENGTH;
mbedAustin 23:05e9bb3b13af 446 } else if (authParams->offset != 0) {
mbedAustin 23:05e9bb3b13af 447 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_OFFSET;
mbedAustin 23:05e9bb3b13af 448 } else if (memcmp(authParams->data, params.lock, sizeof(Lock_t)) != 0) {
mbedAustin 23:05e9bb3b13af 449 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
mbedAustin 23:05e9bb3b13af 450 } else {
mbedAustin 23:05e9bb3b13af 451 authParams->authorizationReply = AUTH_CALLBACK_REPLY_SUCCESS;
mbedAustin 23:05e9bb3b13af 452 }
mbedAustin 23:05e9bb3b13af 453 }
mbedAustin 23:05e9bb3b13af 454
mbedAustin 23:05e9bb3b13af 455 void uriDataWriteAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
mbedAustin 34:5876fbb1aa62 456 if (params.lockedState) {
mbedAustin 23:05e9bb3b13af 457 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
mbedAustin 23:05e9bb3b13af 458 } else if (authParams->offset != 0) {
mbedAustin 23:05e9bb3b13af 459 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_OFFSET;
mbedAustin 23:05e9bb3b13af 460 } else {
mbedAustin 23:05e9bb3b13af 461 authParams->authorizationReply = AUTH_CALLBACK_REPLY_SUCCESS;
mbedAustin 23:05e9bb3b13af 462 }
mbedAustin 23:05e9bb3b13af 463 }
mbedAustin 23:05e9bb3b13af 464
mbedAustin 23:05e9bb3b13af 465 void powerModeAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
mbedAustin 34:5876fbb1aa62 466 if (params.lockedState) {
mbedAustin 23:05e9bb3b13af 467 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
mbedAustin 23:05e9bb3b13af 468 } else if (authParams->len != sizeof(uint8_t)) {
mbedAustin 23:05e9bb3b13af 469 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_ATT_VAL_LENGTH;
mbedAustin 23:05e9bb3b13af 470 } else if (authParams->offset != 0) {
mbedAustin 23:05e9bb3b13af 471 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_OFFSET;
mbedAustin 23:05e9bb3b13af 472 } else if (*((uint8_t *)authParams->data) >= NUM_POWER_MODES) {
mbedAustin 23:05e9bb3b13af 473 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_WRITE_NOT_PERMITTED;
mbedAustin 23:05e9bb3b13af 474 } else {
mbedAustin 23:05e9bb3b13af 475 authParams->authorizationReply = AUTH_CALLBACK_REPLY_SUCCESS;
mbedAustin 23:05e9bb3b13af 476 }
mbedAustin 23:05e9bb3b13af 477 }
mbedAustin 23:05e9bb3b13af 478
mbedAustin 23:05e9bb3b13af 479 template <typename T>
mbedAustin 23:05e9bb3b13af 480 void basicAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
mbedAustin 34:5876fbb1aa62 481 if (params.lockedState) {
mbedAustin 23:05e9bb3b13af 482 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
mbedAustin 23:05e9bb3b13af 483 } else if (authParams->len != sizeof(T)) {
mbedAustin 23:05e9bb3b13af 484 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_ATT_VAL_LENGTH;
mbedAustin 23:05e9bb3b13af 485 } else if (authParams->offset != 0) {
mbedAustin 23:05e9bb3b13af 486 authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_OFFSET;
mbedAustin 23:05e9bb3b13af 487 } else {
mbedAustin 23:05e9bb3b13af 488 authParams->authorizationReply = AUTH_CALLBACK_REPLY_SUCCESS;
mbedAustin 23:05e9bb3b13af 489 }
mbedAustin 23:05e9bb3b13af 490 }
mbedAustin 23:05e9bb3b13af 491
mbedAustin 23:05e9bb3b13af 492 BLEDevice &ble;
mbedAustin 23:05e9bb3b13af 493 Params_t &params;
mbedAustin 23:05e9bb3b13af 494 Ticker timeSinceBootTick;
mbedAustin 23:05e9bb3b13af 495 Timeout switchFrame;
mbedAustin 23:05e9bb3b13af 496 // Default value that is restored on reset
mbedAustin 23:05e9bb3b13af 497 PowerLevels_t &defaultAdvPowerLevels;
mbedAustin 23:05e9bb3b13af 498 uint8_t lockedState;
mbedAustin 23:05e9bb3b13af 499 bool initSucceeded;
mbedAustin 23:05e9bb3b13af 500 uint8_t resetFlag;
mbedAustin 31:11e7a505a4be 501 bool switchFlag;
mbedAustin 23:05e9bb3b13af 502
mbedAustin 44:0e27ee7800b8 503 //UID Default value that is restored on reset
mbedAustin 44:0e27ee7800b8 504 UIDNamespaceID_t defaultUidNamespaceID;
mbedAustin 44:0e27ee7800b8 505 UIDInstanceID_t defaultUidInstanceID;
mbedAustin 44:0e27ee7800b8 506 uint32_t defaultUidAdvPeriod;
mbedAustin 44:0e27ee7800b8 507 int8_t defaultUidPower;
mbedAustin 44:0e27ee7800b8 508 uint16_t uidRFU;
mbedAustin 44:0e27ee7800b8 509 bool uidIsSet;
mbedAustin 44:0e27ee7800b8 510
mbedAustin 44:0e27ee7800b8 511 //URI Default value that is restored on reset
mbedAustin 44:0e27ee7800b8 512 uint8_t defaultUriDataLength;
mbedAustin 44:0e27ee7800b8 513 UriData_t defaultUriData;
mbedAustin 44:0e27ee7800b8 514 int8_t defaultUrlPower;
mbedAustin 44:0e27ee7800b8 515 uint32_t defaultUriAdvPeriod;
mbedAustin 44:0e27ee7800b8 516 bool urlIsSet;
mbedAustin 44:0e27ee7800b8 517
mbedAustin 44:0e27ee7800b8 518 //TLM Default value that is restored on reset
mbedAustin 44:0e27ee7800b8 519 uint8_t defaultTlmVersion;
mbedAustin 44:0e27ee7800b8 520 uint32_t defaultTlmAdvPeriod;
mbedAustin 44:0e27ee7800b8 521 volatile uint16_t TlmBatteryVoltage;
mbedAustin 44:0e27ee7800b8 522 volatile uint16_t TlmBeaconTemp;
mbedAustin 44:0e27ee7800b8 523 volatile uint32_t TlmPduCount;
mbedAustin 44:0e27ee7800b8 524 volatile uint32_t TlmTimeSinceBoot;
mbedAustin 44:0e27ee7800b8 525 bool tlmIsSet;
mbedAustin 23:05e9bb3b13af 526
mbedAustin 23:05e9bb3b13af 527 ReadOnlyGattCharacteristic<uint8_t> lockedStateChar;
mbedAustin 23:05e9bb3b13af 528 WriteOnlyGattCharacteristic<Lock_t> lockChar;
mbedAustin 23:05e9bb3b13af 529 GattCharacteristic uriDataChar;
mbedAustin 23:05e9bb3b13af 530 WriteOnlyGattCharacteristic<Lock_t> unlockChar;
mbedAustin 23:05e9bb3b13af 531 ReadWriteGattCharacteristic<uint8_t> flagsChar;
mbedAustin 23:05e9bb3b13af 532 ReadWriteGattCharacteristic<PowerLevels_t> advPowerLevelsChar;
mbedAustin 23:05e9bb3b13af 533 ReadWriteGattCharacteristic<uint8_t> txPowerModeChar;
mbedAustin 23:05e9bb3b13af 534 ReadWriteGattCharacteristic<uint16_t> beaconPeriodChar;
mbedAustin 23:05e9bb3b13af 535 WriteOnlyGattCharacteristic<uint8_t> resetChar;
mbedAustin 23:05e9bb3b13af 536
mbedAustin 23:05e9bb3b13af 537 };
mbedAustin 23:05e9bb3b13af 538
mbedAustin 33:8c65879e7d52 539 #endif // SERVICES_EDDYSTONEBEACONCONFIGSERVICE_H_