Added an EddystoneURLConfigService in addition to UriBeaconConfigService. Updated README and converted comments that used UriBeacon to EddystoneURL in the EddystoneService.h
Dependents: mbed_EddystoneURL_Beacon_ssci mbed_EddystoneURL_Beacon_ssci mbed_EddystoneURL_Beacon_ssci
Fork of BLE_API by
UARTService.h
00001 /* mbed Microcontroller Library 00002 * Copyright (c) 2006-2013 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_UART_SERVICE_H__ 00018 #define __BLE_UART_SERVICE_H__ 00019 00020 #include "mbed.h" 00021 #include "Stream.h" 00022 00023 #include "ble/UUID.h" 00024 #include "ble/BLE.h" 00025 00026 extern const uint8_t UARTServiceBaseUUID[UUID::LENGTH_OF_LONG_UUID]; 00027 extern const uint16_t UARTServiceShortUUID; 00028 extern const uint16_t UARTServiceTXCharacteristicShortUUID; 00029 extern const uint16_t UARTServiceRXCharacteristicShortUUID; 00030 00031 extern const uint8_t UARTServiceUUID[UUID::LENGTH_OF_LONG_UUID]; 00032 extern const uint8_t UARTServiceUUID_reversed[UUID::LENGTH_OF_LONG_UUID]; 00033 00034 extern const uint8_t UARTServiceTXCharacteristicUUID[UUID::LENGTH_OF_LONG_UUID]; 00035 extern const uint8_t UARTServiceRXCharacteristicUUID[UUID::LENGTH_OF_LONG_UUID]; 00036 00037 /** 00038 * @class UARTService 00039 * @brief BLE Service to enable UART over BLE 00040 */ 00041 class UARTService { 00042 public: 00043 /**< Maximum length of data (in bytes) that can be transmitted by the UART service module to the peer. */ 00044 static const unsigned BLE_UART_SERVICE_MAX_DATA_LEN = (BLE_GATT_MTU_SIZE_DEFAULT - 3); 00045 00046 public: 00047 00048 /** 00049 * @param[ref] ble 00050 * BLE object for the underlying controller. 00051 */ 00052 UARTService (BLE &_ble) : 00053 ble(_ble), 00054 receiveBuffer(), 00055 sendBuffer(), 00056 sendBufferIndex(0), 00057 numBytesReceived(0), 00058 receiveBufferIndex(0), 00059 txCharacteristic(UARTServiceTXCharacteristicUUID, receiveBuffer, 1, BLE_UART_SERVICE_MAX_DATA_LEN, 00060 GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE), 00061 rxCharacteristic(UARTServiceRXCharacteristicUUID, sendBuffer, 1, BLE_UART_SERVICE_MAX_DATA_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY) { 00062 GattCharacteristic *charTable[] = {&txCharacteristic, &rxCharacteristic}; 00063 GattService uartService(UARTServiceUUID, charTable, sizeof(charTable) / sizeof(GattCharacteristic *)); 00064 00065 ble.addService(uartService); 00066 ble.onDataWritten(this, &UARTService::onDataWritten); 00067 } 00068 00069 /** 00070 * Note: TX and RX characteristics are to be interpreted from the viewpoint of the GATT client using this service. 00071 */ 00072 uint16_t getTXCharacteristicHandle() { 00073 return txCharacteristic.getValueAttribute().getHandle(); 00074 } 00075 00076 /** 00077 * Note: TX and RX characteristics are to be interpreted from the viewpoint of the GATT client using this service. 00078 */ 00079 uint16_t getRXCharacteristicHandle() { 00080 return rxCharacteristic.getValueAttribute().getHandle(); 00081 } 00082 00083 /** 00084 * We attempt to collect bytes before pushing them to the UART RX 00085 * characteristic--writing to the RX characteristic will then generate 00086 * notifications for the client. Updates made in quick succession to a 00087 * notification-generating characteristic will result in data being buffered 00088 * in the bluetooth stack as notifications are sent out. The stack will have 00089 * its limits for this buffering; typically a small number under 10. 00090 * Collecting data into the sendBuffer buffer helps mitigate the rate of 00091 * updates. But we shouldn't buffer a large amount of data before updating 00092 * the characteristic otherwise the client will need to turn around and make 00093 * a long read request; this is because notifications include only the first 00094 * 20 bytes of the updated data. 00095 * 00096 * @param buffer The received update 00097 * @param length Amount of characters to be appended. 00098 * @return Amount of characters appended to the rxCharacteristic. 00099 */ 00100 size_t write(const void *_buffer, size_t length) { 00101 size_t origLength = length; 00102 const uint8_t *buffer = static_cast<const uint8_t *>(_buffer); 00103 00104 if (ble.getGapState().connected) { 00105 unsigned bufferIndex = 0; 00106 while (length) { 00107 unsigned bytesRemainingInSendBuffer = BLE_UART_SERVICE_MAX_DATA_LEN - sendBufferIndex; 00108 unsigned bytesToCopy = (length < bytesRemainingInSendBuffer) ? length : bytesRemainingInSendBuffer; 00109 00110 /* copy bytes into sendBuffer */ 00111 memcpy(&sendBuffer[sendBufferIndex], &buffer[bufferIndex], bytesToCopy); 00112 length -= bytesToCopy; 00113 sendBufferIndex += bytesToCopy; 00114 bufferIndex += bytesToCopy; 00115 00116 /* have we collected enough? */ 00117 if ((sendBufferIndex == BLE_UART_SERVICE_MAX_DATA_LEN) || 00118 // (sendBuffer[sendBufferIndex - 1] == '\r') || 00119 (sendBuffer[sendBufferIndex - 1] == '\n')) { 00120 ble.gattServer().write(getRXCharacteristicHandle(), static_cast<const uint8_t *>(sendBuffer), sendBufferIndex); 00121 sendBufferIndex = 0; 00122 } 00123 } 00124 } 00125 00126 return origLength; 00127 } 00128 00129 /** 00130 * Helper function to write out strings. 00131 * @param str The received string. 00132 * @return Amount of characters appended to the rxCharacteristic. 00133 */ 00134 size_t writeString(const char *str) { 00135 return write(str, strlen(str)); 00136 } 00137 00138 /** 00139 * Override for Stream::_putc() 00140 * @param c 00141 * This function writes the character c, cast to an unsigned char, to stream. 00142 * @return 00143 * The character written as an unsigned char cast to an int or EOF on error. 00144 */ 00145 int _putc(int c) { 00146 return (write(&c, 1) == 1) ? 1 : EOF; 00147 } 00148 00149 /** 00150 * Override for Stream::_getc() 00151 * @return 00152 * The character read. 00153 */ 00154 int _getc() { 00155 if (receiveBufferIndex == numBytesReceived) { 00156 return EOF; 00157 } 00158 00159 return receiveBuffer[receiveBufferIndex++]; 00160 } 00161 00162 protected: 00163 /** 00164 * This callback allows the UART service to receive updates to the 00165 * txCharacteristic. The application should forward the call to this 00166 * function from the global onDataWritten() callback handler; or if that's 00167 * not used, this method can be used as a callback directly. 00168 */ 00169 void onDataWritten(const GattWriteCallbackParams *params) { 00170 if (params->handle == getTXCharacteristicHandle()) { 00171 uint16_t bytesRead = params->len; 00172 if (bytesRead <= BLE_UART_SERVICE_MAX_DATA_LEN) { 00173 numBytesReceived = bytesRead; 00174 receiveBufferIndex = 0; 00175 memcpy(receiveBuffer, params->data, numBytesReceived); 00176 } 00177 } 00178 } 00179 00180 protected: 00181 BLE &ble; 00182 00183 uint8_t receiveBuffer[BLE_UART_SERVICE_MAX_DATA_LEN]; /**< The local buffer into which we receive 00184 * inbound data before forwarding it to the 00185 * application. */ 00186 00187 uint8_t sendBuffer[BLE_UART_SERVICE_MAX_DATA_LEN]; /**< The local buffer into which outbound data is 00188 * accumulated before being pushed to the 00189 * rxCharacteristic. */ 00190 uint8_t sendBufferIndex; 00191 uint8_t numBytesReceived; 00192 uint8_t receiveBufferIndex; 00193 00194 GattCharacteristic txCharacteristic; /**< From the point of view of the external client, this is the characteristic 00195 * they'd write into in order to communicate with this application. */ 00196 GattCharacteristic rxCharacteristic; /**< From the point of view of the external client, this is the characteristic 00197 * they'd read from in order to receive the bytes transmitted by this 00198 * application. */ 00199 }; 00200 00201 #endif /* #ifndef __BLE_UART_SERVICE_H__*/
Generated on Tue Jul 12 2022 21:57:19 by 1.7.2