diff --git a/.github/workflows/compile-examples.yml b/.github/workflows/compile-examples.yml index 903abc44..059e70f1 100644 --- a/.github/workflows/compile-examples.yml +++ b/.github/workflows/compile-examples.yml @@ -12,6 +12,9 @@ on: - ".github/workflows/compile-examples.yml" - "examples/**" - "src/**" + schedule: + # Run every Tuesday at 8 AM UTC to catch breakage caused by changes to external resources (libraries, platforms). + - cron: "0 8 * * TUE" workflow_dispatch: jobs: diff --git a/README.md b/README.md index 94d95daa..ca305c4a 100644 --- a/README.md +++ b/README.md @@ -31,6 +31,17 @@ The user can include the file `app_conf_custom.h` to customize the BLE applicati Options wrapped in `#ifndef`, `#endif` in `app_conf_default.h` can be overwritten. Additional options can be added. +The user can refer to [AN5270](https://www.st.com/resource/en/application_note/an5270-introduction-to-stm32wb-bluetooth-low-energy-wireless-interface-stmicroelectronics.pdf) + +##### Examples + +The user can change the Tx Power by redefining `CFG_TX_POWER` using the [`build_opt.h`](https://github.com/stm32duino/Arduino_Core_STM32/wiki/Customize-build-options-using-build_opt.h) file. Possible values are listed in the chapter +**4.2 Tx power level**, default value is `0x18`(`-0.15dBm`). To set it at `+1dBm`, `CFG_TX_POWER` have to be defined at `0x1A`: + +``` +-DCFG_TX_POWER=0x1A +``` + ### Shield The user can include the file `ble_spi_conf.h` to define which shield and configuration to use from the following list: @@ -112,17 +123,17 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ``` -B-L475E-IOT01A: https://www.st.com/en/evaluation-tools/b-l475e-iot01a.html -B-L4S5I-IOT01A: https://www.st.com/en/evaluation-tools/b-l4s5i-iot01a.html -NUCLEO-F401RE: https://www.st.com/en/evaluation-tools/nucleo-f401re.html -NUCLEO-L053R8: https://www.st.com/en/evaluation-tools/nucleo-l053r8.html -NUCLEO-L476RG: https://www.st.com/en/evaluation-tools/nucleo-l476rg.html -NUCLEO-WB15CC: https://www.st.com/en/evaluation-tools/nucleo-wb15cc.html -P-NUCLEO-WB55RG: https://www.st.com/en/evaluation-tools/p-nucleo-wb55.html -STEVAL-MKSBOX1V1: https://www.st.com/en/evaluation-tools/steval-mksbox1v1.html -STEVAL-MKBOXPRO: https://www.st.com/en/evaluation-tools/steval-mkboxpro.html -STM32L562E-DK: https://www.st.com/en/evaluation-tools/stm32l562e-dk.html -STM32WB5MM-DK: https://www.st.com/en/evaluation-tools/stm32wb5mm-dk.html -X-NUCLEO-BNRG2A1: https://www.st.com/en/ecosystems/x-nucleo-bnrg2a1.html -X-NUCLEO-IDB05A2: https://www.st.com/en/ecosystems/x-nucleo-idb05a2.html -X-NUCLEO-IDB05A1: https://www.st.com/en/ecosystems/x-nucleo-idb05a1.html +[B-L475E-IOT01A]: https://www.st.com/en/evaluation-tools/b-l475e-iot01a.html +[B-L4S5I-IOT01A]: https://www.st.com/en/evaluation-tools/b-l4s5i-iot01a.html +[NUCLEO-F401RE]: https://www.st.com/en/evaluation-tools/nucleo-f401re.html +[NUCLEO-L053R8]: https://www.st.com/en/evaluation-tools/nucleo-l053r8.html +[NUCLEO-L476RG]: https://www.st.com/en/evaluation-tools/nucleo-l476rg.html +[NUCLEO-WB15CC]: https://www.st.com/en/evaluation-tools/nucleo-wb15cc.html +[P-NUCLEO-WB55RG]: https://www.st.com/en/evaluation-tools/p-nucleo-wb55.html +[STEVAL-MKSBOX1V1]: https://www.st.com/en/evaluation-tools/steval-mksbox1v1.html +[STEVAL-MKBOXPRO]: https://www.st.com/en/evaluation-tools/steval-mkboxpro.html +[STM32L562E-DK]: https://www.st.com/en/evaluation-tools/stm32l562e-dk.html +[STM32WB5MM-DK]: https://www.st.com/en/evaluation-tools/stm32wb5mm-dk.html +[X-NUCLEO-BNRG2A1]: https://www.st.com/en/ecosystems/x-nucleo-bnrg2a1.html +[X-NUCLEO-IDB05A2]: https://www.st.com/en/ecosystems/x-nucleo-idb05a2.html +[X-NUCLEO-IDB05A1]: https://www.st.com/en/ecosystems/x-nucleo-idb05a1.html diff --git a/extras/test/src/test_characteristic/test_permissions.cpp b/extras/test/src/test_characteristic/test_permissions.cpp new file mode 100644 index 00000000..cd658580 --- /dev/null +++ b/extras/test/src/test_characteristic/test_permissions.cpp @@ -0,0 +1,126 @@ +/* + This file is part of the ArduinoBLE library. + Copyright (c) 2018 Arduino SA. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include + +#define private public +#define protected public + +#include "FakeBLELocalDevice.h" +#include "BLEAdvertisingData.h" +#include "BLETypedCharacteristics.h" +#include "BLELocalCharacteristic.h" +#include "BLEStringCharacteristic.h" +#include "BLEProperty.h" +#include + +int property[] = { + BLEBroadcast, + BLERead, + BLEWriteWithoutResponse, + BLEWrite, + BLENotify, + BLEIndicate, + BLEAuthSignedWrite, + BLEExtProp, + BLERead | BLEWrite | BLENotify +}; + +int permission[] = { + BLEEncryption, + BLEAuthentication, + BLEAuthorization, + BLEEncryption | BLEAuthentication +}; + +const char uuid[][31] = { + "1 Bool", + "2 Char", + "3 UnsignedChar", + "4 Byte", + "5 Short", + "6 UnsignedShort", + "7 Word", + "8 Int", + "9 UnsignedInt", + "A Long", + "B UnsignedLong", + "C Float", + "D Double", + "E String" +}; + +std::unique_ptr createCharacteristic(const char* uuid, unsigned int properties) +{ + switch(uuid[0]) + { + case '1': + return std::unique_ptr(new BLEBoolCharacteristic(uuid, properties)); + case '2': + return std::unique_ptr(new BLECharCharacteristic(uuid, properties)); + case '3': + return std::unique_ptr(new BLEUnsignedCharCharacteristic(uuid, properties)); + case '4': + return std::unique_ptr(new BLEByteCharacteristic(uuid, properties)); + case '5': + return std::unique_ptr(new BLEShortCharacteristic(uuid, properties)); + case '6': + return std::unique_ptr(new BLEUnsignedShortCharacteristic(uuid, properties)); + case '7': + return std::unique_ptr(new BLEWordCharacteristic(uuid, properties)); + case '8': + return std::unique_ptr(new BLEIntCharacteristic(uuid, properties)); + case '9': + return std::unique_ptr(new BLEUnsignedIntCharacteristic(uuid, properties)); + case 'A': + return std::unique_ptr(new BLELongCharacteristic(uuid, properties)); + case 'B': + return std::unique_ptr(new BLEUnsignedLongCharacteristic(uuid, properties)); + case 'C': + return std::unique_ptr(new BLEFloatCharacteristic(uuid, properties)); + case 'D': + return std::unique_ptr(new BLEDoubleCharacteristic(uuid, properties)); + case 'E': + return std::unique_ptr(new BLEStringCharacteristic(uuid, properties, 2)); + default: + break; + } + return nullptr; +} + +TEST_CASE("Test characteristic properties and permissions", "[ArduinoBLE::BLECharacteristic]") +{ + WHEN("Create a characteristic") + { + for(int i = 0; i < sizeof(property)/sizeof(int); i++) + { + for(int j = 0; j < sizeof(permission)/sizeof(int); j++) + { + for(int k = 0; k < 14; k++) + { + std::unique_ptr ptr = createCharacteristic(uuid[k], property[i] | permission[j]); + REQUIRE(ptr != nullptr); + REQUIRE(ptr->properties() == (property[i])); + BLELocalCharacteristic * local = ptr->local(); + REQUIRE(local->permissions() == (permission[j] >> 8)); + } + } + } + } +} diff --git a/extras/test/src/test_characteristic/test_writeValue.cpp b/extras/test/src/test_characteristic/test_writeValue.cpp new file mode 100644 index 00000000..6c7e1cd1 --- /dev/null +++ b/extras/test/src/test_characteristic/test_writeValue.cpp @@ -0,0 +1,389 @@ +/* + This file is part of the ArduinoBLE library. + Copyright (c) 2018 Arduino SA. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include + +#define private public +#define protected public + +#include "FakeBLELocalDevice.h" +#include "BLEAdvertisingData.h" +#include "BLETypedCharacteristics.h" +#include "BLELocalCharacteristic.h" +#include "BLEStringCharacteristic.h" +#include "BLEProperty.h" + + +TEST_CASE("Test characteristic writeValue", "[ArduinoBLE::BLECharacteristic]") +{ + WHEN("Create a bool characteristic") + { + BLEBoolCharacteristic boolCharacteristic("Bool", BLEBroadcast| BLEIndicate | BLENotify ); + bool v = false;; + int written = boolCharacteristic.writeValue(v); + REQUIRE( written == sizeof(bool) ); + + boolCharacteristic.broadcast(); + written = boolCharacteristic.writeValue(v); + REQUIRE( written == sizeof(bool) ); + + BLEDevice device; + boolCharacteristic.local()->writeCccdValue(device, 0x002); + written = boolCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + boolCharacteristic.local()->writeCccdValue(device, 0x001); + written = boolCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a boolean characteristic") + { + BLEBooleanCharacteristic booleanCharacteristic("Boolean", BLEBroadcast| BLEIndicate | BLENotify); + bool v = false; + int written = booleanCharacteristic.writeValue(v); + REQUIRE( written == sizeof(bool) ); + + booleanCharacteristic.broadcast(); + written = booleanCharacteristic.writeValue(v); + REQUIRE( written == sizeof(bool) ); + + BLEDevice device; + booleanCharacteristic.local()->writeCccdValue(device, 0x002); + written = booleanCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + booleanCharacteristic.local()->writeCccdValue(device, 0x001); + written = booleanCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a char characteristic") + { + BLECharCharacteristic charCharacteristic("Char", BLEBroadcast| BLEIndicate | BLENotify); + char v = 'a'; + int written = charCharacteristic.writeValue(v); + REQUIRE( written == sizeof(char) ); + + charCharacteristic.broadcast(); + written = charCharacteristic.writeValue(v); + REQUIRE( written == sizeof(char) ); + + BLEDevice device; + charCharacteristic.local()->writeCccdValue(device, 0x002); + written = charCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + charCharacteristic.local()->writeCccdValue(device, 0x001); + written = charCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a unsigned char characteristic") + { + BLEUnsignedCharCharacteristic unsignedCharCharacteristic("UnsignedChar", BLEBroadcast| BLEIndicate | BLENotify); + unsigned char v = 0x01; + int written = unsignedCharCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned char) ); + + unsignedCharCharacteristic.broadcast(); + written = unsignedCharCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned char) ); + + BLEDevice device; + unsignedCharCharacteristic.local()->writeCccdValue(device, 0x002); + written = unsignedCharCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + unsignedCharCharacteristic.local()->writeCccdValue(device, 0x001); + written = unsignedCharCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a byte characteristic") + { + BLEByteCharacteristic byteCharacteristic("Byte", BLEBroadcast| BLEIndicate | BLENotify); + byte v = 0x01; + int written = byteCharacteristic.writeValue(v); + REQUIRE( written == sizeof(byte) ); + + byteCharacteristic.broadcast(); + written = byteCharacteristic.writeValue(v); + REQUIRE( written == sizeof(byte) ); + + BLEDevice device; + byteCharacteristic.local()->writeCccdValue(device, 0x002); + written = byteCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + byteCharacteristic.local()->writeCccdValue(device, 0x001); + written = byteCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a short characteristic") + { + BLEShortCharacteristic shortCharacteristic("Short", BLEBroadcast| BLEIndicate | BLENotify); + short v = -1; + int written = shortCharacteristic.writeValue(v); + REQUIRE( written == sizeof(short) ); + + shortCharacteristic.broadcast(); + written = shortCharacteristic.writeValue(v); + REQUIRE( written == sizeof(short) ); + + BLEDevice device; + shortCharacteristic.local()->writeCccdValue(device, 0x002); + written = shortCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + shortCharacteristic.local()->writeCccdValue(device, 0x001); + written = shortCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a unsigned short characteristic") + { + BLEUnsignedShortCharacteristic unsignedShortCharacteristic("UnsignedShort", BLEBroadcast| BLEIndicate | BLENotify); + unsigned short v = 1; + int written = unsignedShortCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned short) ); + + unsignedShortCharacteristic.broadcast(); + written = unsignedShortCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned short) ); + + BLEDevice device; + unsignedShortCharacteristic.local()->writeCccdValue(device, 0x002); + written = unsignedShortCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + unsignedShortCharacteristic.local()->writeCccdValue(device, 0x001); + written = unsignedShortCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a word characteristic") + { + BLEWordCharacteristic wordCharacteristic("Word", BLEBroadcast| BLEIndicate | BLENotify); + word v = -1; + int written = wordCharacteristic.writeValue(v); + REQUIRE( written == sizeof(word) ); + + wordCharacteristic.broadcast(); + written = wordCharacteristic.writeValue(v); + REQUIRE( written == sizeof(word) ); + + BLEDevice device; + wordCharacteristic.local()->writeCccdValue(device, 0x002); + written = wordCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + wordCharacteristic.local()->writeCccdValue(device, 0x001); + written = wordCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a int characteristic") + { + BLEIntCharacteristic intCharacteristic("Int", BLEBroadcast| BLEIndicate | BLENotify); + int v = -1; + int written = intCharacteristic.writeValue(v); + REQUIRE( written == sizeof(int) ); + + intCharacteristic.broadcast(); + written = intCharacteristic.writeValue(v); + REQUIRE( written == sizeof(int) ); + + BLEDevice device; + intCharacteristic.local()->writeCccdValue(device, 0x002); + written = intCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + intCharacteristic.local()->writeCccdValue(device, 0x001); + written = intCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a unsigned int characteristic") + { + BLEUnsignedIntCharacteristic unsignedIntCharacteristic("UnsignedInt", BLEBroadcast| BLEIndicate | BLENotify); + unsigned int v = 1; + int written = unsignedIntCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned int) ); + + unsignedIntCharacteristic.broadcast(); + written = unsignedIntCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned int) ); + + BLEDevice device; + unsignedIntCharacteristic.local()->writeCccdValue(device, 0x002); + written = unsignedIntCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + unsignedIntCharacteristic.local()->writeCccdValue(device, 0x001); + written = unsignedIntCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a long characteristic") + { + BLELongCharacteristic longCharacteristic("Long", BLEBroadcast| BLEIndicate | BLENotify); + long v = -1; + int written = longCharacteristic.writeValue(v); + REQUIRE( written == sizeof(long) ); + + longCharacteristic.broadcast(); + written = longCharacteristic.writeValue(v); + REQUIRE( written == sizeof(long) ); + + BLEDevice device; + longCharacteristic.local()->writeCccdValue(device, 0x002); + written = longCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + longCharacteristic.local()->writeCccdValue(device, 0x001); + written = longCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a unsigned long characteristic") + { + BLEUnsignedLongCharacteristic unsignedLongCharacteristic("UnsignedLong", BLEBroadcast| BLEIndicate | BLENotify); + unsigned long v = 1; + int written = unsignedLongCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned long) ); + + unsignedLongCharacteristic.broadcast(); + written = unsignedLongCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned long) ); + + BLEDevice device; + unsignedLongCharacteristic.local()->writeCccdValue(device, 0x002); + written = unsignedLongCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + unsignedLongCharacteristic.local()->writeCccdValue(device, 0x001); + written = unsignedLongCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a float characteristic") + { + BLEFloatCharacteristic floatCharacteristic("Float", BLEBroadcast| BLEIndicate | BLENotify); + float v = -1.0f; + int written = floatCharacteristic.writeValue(v); + REQUIRE( written == sizeof(float) ); + + floatCharacteristic.broadcast(); + written = floatCharacteristic.writeValue(v); + REQUIRE( written == sizeof(float) ); + + BLEDevice device; + floatCharacteristic.local()->writeCccdValue(device, 0x002); + written = floatCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + floatCharacteristic.local()->writeCccdValue(device, 0x001); + written = floatCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a double characteristic") + { + BLEDoubleCharacteristic doubleCharacteristic("Double", BLEBroadcast| BLEIndicate | BLENotify); + double v = -1.0; + int written = doubleCharacteristic.writeValue(v); + REQUIRE( written == sizeof(double) ); + + doubleCharacteristic.broadcast(); + written = doubleCharacteristic.writeValue(v); + REQUIRE( written == sizeof(double) ); + + BLEDevice device; + doubleCharacteristic.local()->writeCccdValue(device, 0x002); + written = doubleCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + doubleCharacteristic.local()->writeCccdValue(device, 0x001); + written = doubleCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a string characteristic") + { + const int maxStringLength = 64; + BLEStringCharacteristic stringCharacteristic("String", BLEBroadcast| BLEIndicate | BLENotify, maxStringLength); + const char* v = "Hello"; + int written = stringCharacteristic.writeValue(v); + REQUIRE( written == min(strlen(v), maxStringLength) ); + + stringCharacteristic.broadcast(); + written = stringCharacteristic.writeValue(v); + REQUIRE( written == min(strlen(v), maxStringLength) ); + + BLEDevice device; + stringCharacteristic.local()->writeCccdValue(device, 0x002); + written = stringCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + stringCharacteristic.local()->writeCccdValue(device, 0x001); + written = stringCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a too long string characteristic") + { + const int maxStringLength = 4; + BLEStringCharacteristic stringCharacteristic("String", BLEBroadcast| BLEIndicate | BLENotify, maxStringLength); + const char* v = "Hello"; + int written = stringCharacteristic.writeValue(v); + REQUIRE( written == min(strlen(v), maxStringLength) ); + + stringCharacteristic.broadcast(); + written = stringCharacteristic.writeValue(v); + REQUIRE( written == min(strlen(v), maxStringLength) ); + + BLEDevice device; + stringCharacteristic.local()->writeCccdValue(device, 0x002); + written = stringCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + stringCharacteristic.local()->writeCccdValue(device, 0x001); + written = stringCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + +} diff --git a/keywords.txt b/keywords.txt index b908b573..150e6262 100644 --- a/keywords.txt +++ b/keywords.txt @@ -119,10 +119,6 @@ valueBE KEYWORD2 uuid KEYWORD2 addCharacteristic KEYWORD2 -wait KEYWORD2 -peek KEYWORD2 -write KEYWORD2 - ####################################### # Constants (LITERAL1) ####################################### diff --git a/library.properties b/library.properties index 1842c0ee..24c38d09 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=STM32duinoBLE -version=1.3.7 +version=1.4.0 author=Arduino, SRA maintainer=stm32duino sentence=Fork of ArduinoBLE library to add the support of STM32WB, SPBTLE-RF, SPBTLE-1S, BLUENRG-M2SP, BLUENRG-LP and BLUENRG-M0 BLE modules. diff --git a/src/BLEStringCharacteristic.cpp b/src/BLEStringCharacteristic.cpp index 76f0812c..a12e722d 100644 --- a/src/BLEStringCharacteristic.cpp +++ b/src/BLEStringCharacteristic.cpp @@ -19,7 +19,7 @@ #include "BLEStringCharacteristic.h" -BLEStringCharacteristic::BLEStringCharacteristic(const char* uuid, unsigned char properties, int valueSize) : +BLEStringCharacteristic::BLEStringCharacteristic(const char* uuid, unsigned int properties, int valueSize) : BLECharacteristic(uuid, properties, valueSize) { } diff --git a/src/BLEStringCharacteristic.h b/src/BLEStringCharacteristic.h index c9f28fca..65604846 100644 --- a/src/BLEStringCharacteristic.h +++ b/src/BLEStringCharacteristic.h @@ -27,7 +27,7 @@ class BLEStringCharacteristic : public BLECharacteristic { public: - BLEStringCharacteristic(const char* uuid, unsigned char properties, int valueSize); + BLEStringCharacteristic(const char* uuid, unsigned int properties, int valueSize); int writeValue(const String& value); int setValue(const String& value) { return writeValue(value); } diff --git a/src/local/BLELocalCharacteristic.cpp b/src/local/BLELocalCharacteristic.cpp index 207425bd..dc8a819d 100644 --- a/src/local/BLELocalCharacteristic.cpp +++ b/src/local/BLELocalCharacteristic.cpp @@ -126,15 +126,13 @@ int BLELocalCharacteristic::writeValue(const uint8_t value[], int length) if (_broadcast) { uint16_t serviceUuid = GATT.serviceUuidForCharacteristic(this); - - BLE.setAdvertisedServiceData(serviceUuid, value, length); - + BLE.setAdvertisedServiceData(serviceUuid, value, _valueLength); if (!ATT.connected() && GAP.advertising()) { BLE.advertise(); } } - return 1; + return _valueLength; } int BLELocalCharacteristic::writeValue(const char* value) diff --git a/src/utility/ATT.cpp b/src/utility/ATT.cpp index d19b9b92..4fe4b71a 100644 --- a/src/utility/ATT.cpp +++ b/src/utility/ATT.cpp @@ -553,6 +553,22 @@ bool ATTClass::disconnect() numDisconnects++; + BLEDevice bleDevice(_peers[i].addressType, _peers[i].address); + + // clear CCCD values on disconnect + for (uint16_t att = 0; att < GATT.attributeCount(); att++) { + BLELocalAttribute* attribute = GATT.attribute(att); + + if (attribute->type() == BLETypeCharacteristic) { + BLELocalCharacteristic* characteristic = (BLELocalCharacteristic*)attribute; + + characteristic->writeCccdValue(bleDevice, 0x0000); + } + } + + _longWriteHandle = 0x0000; + _longWriteValueLength = 0; + _peers[i].connectionHandle = 0xffff; _peers[i].role = 0x00; _peers[i].addressType = 0x00; @@ -582,7 +598,7 @@ BLEDevice ATTClass::central() return BLEDevice(); } -bool ATTClass::handleNotify(uint16_t handle, const uint8_t* value, int length) +int ATTClass::handleNotify(uint16_t handle, const uint8_t* value, int length) { int numNotifications = 0; @@ -610,10 +626,10 @@ bool ATTClass::handleNotify(uint16_t handle, const uint8_t* value, int length) numNotifications++; } - return (numNotifications > 0); + return (numNotifications > 0) ? length : 0; } -bool ATTClass::handleInd(uint16_t handle, const uint8_t* value, int length) +int ATTClass::handleInd(uint16_t handle, const uint8_t* value, int length) { int numIndications = 0; @@ -650,7 +666,7 @@ bool ATTClass::handleInd(uint16_t handle, const uint8_t* value, int length) numIndications++; } - return (numIndications > 0); + return (numIndications > 0) ? length : 0; } void ATTClass::error(uint16_t connectionHandle, uint8_t dlen, uint8_t data[]) diff --git a/src/utility/ATT.h b/src/utility/ATT.h index 5e41e1fa..2d69d2b5 100644 --- a/src/utility/ATT.h +++ b/src/utility/ATT.h @@ -83,8 +83,8 @@ class ATTClass { virtual BLEDevice central(); - virtual bool handleNotify(uint16_t handle, const uint8_t* value, int length); - virtual bool handleInd(uint16_t handle, const uint8_t* value, int length); + virtual int handleNotify(uint16_t handle, const uint8_t* value, int length); + virtual int handleInd(uint16_t handle, const uint8_t* value, int length); virtual void setEventHandler(BLEDeviceEvent event, BLEDeviceEventHandler eventHandler); diff --git a/src/utility/GATT.cpp b/src/utility/GATT.cpp index be914f6f..3550fd99 100644 --- a/src/utility/GATT.cpp +++ b/src/utility/GATT.cpp @@ -70,21 +70,31 @@ void GATTClass::begin() void GATTClass::end() { - if (_genericAccessService->release() == 0) + if (_genericAccessService && _genericAccessService->release() == 0) { delete(_genericAccessService); - - if (_deviceNameCharacteristic->release() == 0) + _genericAccessService = NULL; + } + + if (_deviceNameCharacteristic && _deviceNameCharacteristic->release() == 0) { delete(_deviceNameCharacteristic); - - if (_appearanceCharacteristic->release() == 0) + _deviceNameCharacteristic = NULL; + } + + if (_appearanceCharacteristic && _appearanceCharacteristic->release() == 0) { delete(_appearanceCharacteristic); - - if (_genericAttributeService->release() == 0) + _appearanceCharacteristic = NULL; + } + + if (_genericAttributeService && _genericAttributeService->release() == 0) { delete(_genericAttributeService); - - if (_servicesChangedCharacteristic->release() == 0) + _genericAttributeService = NULL; + } + + if (_servicesChangedCharacteristic && _servicesChangedCharacteristic->release() == 0) { delete(_servicesChangedCharacteristic); - + _servicesChangedCharacteristic = NULL; + } + clearAttributes(); } diff --git a/src/utility/HCI.cpp b/src/utility/HCI.cpp index 8ac2419a..ebe66a27 100644 --- a/src/utility/HCI.cpp +++ b/src/utility/HCI.cpp @@ -485,6 +485,7 @@ void HCIClass::leAddResolvingAddress(uint8_t addressType, uint8_t* peerAddress, addDevice.peerIRK[15-i] = peerIrk[i]; addDevice.localIRK[15-i] = localIrk[i]; } +#ifdef _BLE_TRACE_ Serial.print("ADDTYPE :"); btct.printBytes(&addDevice.peerAddressType,1); Serial.print("adddddd :"); @@ -493,6 +494,7 @@ void HCIClass::leAddResolvingAddress(uint8_t addressType, uint8_t* peerAddress, btct.printBytes(addDevice.peerIRK,16); Serial.print("localIRK :"); btct.printBytes(addDevice.localIRK,16); +#endif sendCommand(OGF_LE_CTL << 10 | 0x27, sizeof(addDevice), &addDevice); leStartResolvingAddresses(); @@ -516,6 +518,7 @@ int HCIClass::leReadPeerResolvableAddress(uint8_t peerAddressType, uint8_t* peer int res = sendCommand(OGF_LE_CTL << 10 | 0x2B, sizeof(request), &request); +#ifdef _BLE_TRACE_ Serial.print("res: 0x"); Serial.println(res, HEX); if(res==0){ @@ -528,6 +531,7 @@ int HCIClass::leReadPeerResolvableAddress(uint8_t peerAddressType, uint8_t* peer Serial.print("peer resolvable address: "); btct.printBytes(response->peerResolvableAddress,6); } + #endif return res; } @@ -566,7 +570,9 @@ int HCIClass::tryResolveAddress(uint8_t* BDAddr, uint8_t* address){ if(!HCI._getIRKs(&nIRKs, BDAddrType, BADDRs, IRKs)){ +#ifdef _BLE_TRACE_ Serial.println("error getting IRKs."); +#endif } for(int i=0; i0){ Serial.print(", 0x"); @@ -36,7 +37,13 @@ void BluetoothCryptoToolbox::printBytes(uint8_t bytes[], uint8_t length){ Serial.print(bytes[i],HEX); } Serial.print('\n'); +#else + (void)bytes; + (void)length; +#endif } + + int BluetoothCryptoToolbox::f5(uint8_t DHKey[],uint8_t N_master[], uint8_t N_slave[], uint8_t BD_ADDR_master[], uint8_t BD_ADDR_slave[], uint8_t MacKey[], uint8_t LTK[]) { @@ -126,17 +133,17 @@ int BluetoothCryptoToolbox::ah(uint8_t k[16], uint8_t r[3], uint8_t* result) } void BluetoothCryptoToolbox::testAh() { - uint8_t irk[16] = {0xec,0x02,0x34,0xa3,0x57,0xc8,0xad,0x05,0x34,0x10,0x10,0xa6,0x0a,0x39,0x7d,0x9b}; + uint8_t irk[16] = {0xec,0x02,0x34,0xa3,0x57,0xc8,0xad,0x05,0x34,0x10,0x10,0xa6,0x0a,0x39,0x7d,0x9b}; uint8_t expected_final[3] = {0x0d,0xfb,0xaa}; - uint8_t ourResult[3]; ah(irk, expected_final, ourResult); - +#ifdef _BLE_TRACE_ Serial.print("Expected : "); printBytes(&expected_final[3], 3); Serial.print("Actual : "); printBytes(ourResult, 3); +#endif } int BluetoothCryptoToolbox::g2(uint8_t U[], uint8_t V[], uint8_t X[], uint8_t Y[], uint8_t out[4]) @@ -160,19 +167,17 @@ void BluetoothCryptoToolbox::testg2(){ uint8_t X[16] = {0xd5,0xcb,0x84,0x54,0xd1,0x77,0x73,0x3e,0xff,0xff,0xb2,0xec,0x71,0x2b,0xae,0xab}; uint8_t Y[16] = {0xa6,0xe8,0xe7,0xcc,0x25,0xa7,0x5f,0x6e,0x21,0x65,0x83,0xf7,0xff,0x3d,0xc4,0xcf}; uint8_t out[4]; - - - uint32_t expected = 0; + g2(U,V,X,Y,out); uint32_t result = 0; for(int i=0; i<4; i++) result += out[i] << 8*i; - Serial.print("Expected : "); - Serial.println(expected); +#ifdef _BLE_TRACE_ + Serial.println("Expected : 0"); Serial.print("Result : "); Serial.println(result); Serial.println(); - +#endif } void BluetoothCryptoToolbox::AES_CMAC ( unsigned char *key, unsigned char *input, int length, @@ -264,8 +269,10 @@ int BluetoothCryptoToolbox::AES_128(uint8_t* key, uint8_t* data_in, uint8_t* dat int n = 0; int tries = 30; while(HCI.leEncrypt(key,data_in, &status, data_out)!=1&&n pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy