sensor/patchedBLE/src/BLEValue.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

/*
 * BLEValue.cpp
 *
 *  Created on: Jul 17, 2017
 *      Author: kolban
 */
#include "sdkconfig.h"
#if defined(CONFIG_BT_ENABLED)
 
#include <esp_log.h>
 
#include "BLEValue.h"
#ifdef ARDUINO_ARCH_ESP32
#include "esp32-hal-log.h"
#endif
 
static const char* LOG_TAG="BLEValue";
 
BLEValue::BLEValue() {
	m_accumulation = "";
	m_value        = "";
	m_readOffset   = 0;
} // BLEValue 
 
 
/**
 * @brief Add a message part to the accumulation.
 * The accumulation is a growing set of data that is added to until a commit or cancel.
 * @param [in] part A message part being added.
 */
void BLEValue::addPart(std::string part) {
	ESP_LOGD(LOG_TAG, ">> addPart: length=%d", part.length());
	m_accumulation += part;
} // addPart 
 
 
/**
 * @brief Add a message part to the accumulation.
 * The accumulation is a growing set of data that is added to until a commit or cancel.
 * @param [in] pData A message part being added.
 * @param [in] length The number of bytes being added.
 */
void BLEValue::addPart(uint8_t* pData, size_t length) {
	ESP_LOGD(LOG_TAG, ">> addPart: length=%d", length);
	m_accumulation += std::string((char *)pData, length);
} // addPart 
 
 
/**
 * @brief Cancel the current accumulation.
 */
void BLEValue::cancel() {
	ESP_LOGD(LOG_TAG, ">> cancel");
	m_accumulation = "";
	m_readOffset   = 0;
} // cancel 
 
 
/**
 * @brief Commit the current accumulation.
 * When writing a value, we may find that we write it in "parts" meaning that the writes come in in pieces
 * of the overall message.  After the last part has been received, we may perform a commit which means that
 * we now have the complete message and commit the change as a unit.
 */
void BLEValue::commit() {
	ESP_LOGD(LOG_TAG, ">> commit");
	// If there is nothing to commit, do nothing. 
	if (m_accumulation.length() == 0) {
		return;
	}
	setValue(m_accumulation);
	m_accumulation = "";
	m_readOffset   = 0;
} // commit 
 
 
/**
 * @brief Get a pointer to the data.
 * @return A pointer to the data.
 */
uint8_t* BLEValue::getData() {
	return (uint8_t*)m_value.data();
}
 
 
/**
 * @brief Get the length of the data in bytes.
 * @return The length of the data in bytes.
 */
size_t BLEValue::getLength() {
	return m_value.length();
} // getLength 
 
 
/**
 * @brief Get the read offset.
 * @return The read offset into the read.
 */
uint16_t BLEValue::getReadOffset() {
	return m_readOffset;
} // getReadOffset 
 
 
/**
 * @brief Get the current value.
 */
std::string BLEValue::getValue() {
	return m_value;
} // getValue 
 
 
/**
 * @brief Set the read offset
 * @param [in] readOffset The offset into the read.
 */
void BLEValue::setReadOffset(uint16_t readOffset) {
	m_readOffset = readOffset;
} // setReadOffset 
 
 
/**
 * @brief Set the current value.
 */
void BLEValue::setValue(std::string value) {
	m_value = value;
} // setValue 
 
 
/**
 * @brief Set the current value.
 * @param [in] pData The data for the current value.
 * @param [in] The length of the new current value.
 */
void BLEValue::setValue(uint8_t* pData, size_t length) {
	m_value = std::string((char*)pData, length);
} // setValue 
 
 
 
 
 
#endif // CONFIG_BT_ENABLED