18#ifndef NIMBLE_CPP_STREAM_H
19#define NIMBLE_CPP_STREAM_H
21#include "syscfg/syscfg.h"
22#if CONFIG_BT_NIMBLE_ENABLED && (MYNEWT_VAL(BLE_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_ROLE_CENTRAL))
24# ifdef USING_NIMBLE_ARDUINO_HEADERS
25# include "nimble/nimble/include/nimble/nimble_npl.h"
27# include "nimble/nimble_npl.h"
31# include <type_traits>
34# ifndef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
35# define NIMBLE_CPP_ARDUINO_STRING_AVAILABLE (__has_include(<Arduino.h>))
38# if NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
46 virtual size_t write(uint8_t) = 0;
47 virtual size_t write(
const uint8_t* buffer,
size_t size) = 0;
48 size_t print(
const char* s);
49 size_t println(
const char* s);
50 size_t printf(
const char* format, ...) __attribute__((format(printf, 2, 3)));
53class Stream : public Print {
55 virtual int available() = 0;
56 virtual int read() = 0;
57 virtual int peek() = 0;
58 virtual int availableForWrite() {
return 0; }
59 virtual void flush() {}
60 void setTimeout(
unsigned long timeout) { m_timeout = timeout; }
61 unsigned long getTimeout()
const {
return m_timeout; }
64 unsigned long m_timeout{0};
68class NimBLEStream :
public Stream {
70 enum RxOverflowAction {
75 using RxOverflowCallback = std::function<RxOverflowAction(
const uint8_t* data,
size_t len,
void* userArg)>;
77 NimBLEStream() =
default;
78 virtual ~NimBLEStream() { end(); }
81 virtual size_t write(
const uint8_t* data,
size_t len)
override;
82 virtual size_t write(uint8_t data)
override {
return write(&data, 1); }
86 typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, uint8_t>::value,
size_t>::type write(T data) {
87 return write(
static_cast<uint8_t
>(data));
90 int availableForWrite()
override;
93 size_t read(uint8_t* buffer,
size_t len);
96 virtual int available()
override;
97 virtual int read()
override;
98 virtual int peek()
override;
99 virtual bool ready()
const = 0;
106 void setRxOverflowCallback(RxOverflowCallback cb,
void* userArg =
nullptr) {
107 m_rxOverflowCallback = cb;
108 m_rxOverflowUserArg = userArg;
111 operator bool()
const {
return ready(); }
115 struct ByteRingBuffer;
120 size_t pushRx(
const uint8_t* data,
size_t len);
122 virtual bool send() = 0;
123 static void txDrainEventCb(
struct ble_npl_event* ev);
124 static void txDrainCalloutCb(
struct ble_npl_event* ev);
126 ByteRingBuffer* m_txBuf{
nullptr};
127 ByteRingBuffer* m_rxBuf{
nullptr};
128 uint8_t m_txChunkBuf[MYNEWT_VAL(BLE_ATT_PREFERRED_MTU)];
129 uint32_t m_txBufSize{1024};
130 uint32_t m_rxBufSize{1024};
131 ble_npl_event m_txDrainEvent{};
132 ble_npl_callout m_txDrainCallout{};
133 RxOverflowCallback m_rxOverflowCallback{
nullptr};
134 void* m_rxOverflowUserArg{
nullptr};
135 bool m_coInitialized{
false};
136 bool m_eventInitialized{
false};
139# if MYNEWT_VAL(BLE_ROLE_PERIPHERAL)
140# include "NimBLECharacteristic.h"
142class NimBLEStreamServer :
public NimBLEStream {
144 NimBLEStreamServer() : m_charCallbacks(this) {}
145 ~NimBLEStreamServer()
override { end(); }
148 NimBLEStreamServer(
const NimBLEStreamServer&) =
delete;
149 NimBLEStreamServer& operator=(
const NimBLEStreamServer&) =
delete;
151 bool begin(NimBLECharacteristic* chr, uint32_t txBufSize = 1024, uint32_t rxBufSize = 1024);
156 uint32_t txBufSize = 1024,
157 uint32_t rxBufSize = 1024,
158 bool secure =
false);
161 size_t write(
const uint8_t* data,
size_t len)
override;
162 uint16_t getPeerHandle()
const {
return m_charCallbacks.m_peerHandle; }
163 void setCallbacks(NimBLECharacteristicCallbacks* pCallbacks) { m_charCallbacks.m_userCallbacks = pCallbacks; }
164 bool ready()
const override;
165 virtual void flush()
override;
167 using NimBLEStream::write;
170 bool send()
override;
172 struct ChrCallbacks :
public NimBLECharacteristicCallbacks {
173 ChrCallbacks(NimBLEStreamServer* parent)
174 : m_parent(parent), m_userCallbacks(nullptr), m_peerHandle(BLE_HS_CONN_HANDLE_NONE) {}
175 void onWrite(NimBLECharacteristic* pCharacteristic,
NimBLEConnInfo& connInfo)
override;
176 void onSubscribe(NimBLECharacteristic* pCharacteristic,
NimBLEConnInfo& connInfo, uint16_t subValue)
override;
177 void onStatus(NimBLECharacteristic* pCharacteristic,
NimBLEConnInfo& connInfo,
int code)
override;
179 void onStatus(NimBLECharacteristic* pCharacteristic,
int code)
override {
180 if (m_userCallbacks !=
nullptr) {
181 m_userCallbacks->onStatus(pCharacteristic, code);
185 NimBLEStreamServer* m_parent;
186 NimBLECharacteristicCallbacks* m_userCallbacks;
187 uint16_t m_peerHandle;
190 NimBLECharacteristic* m_pChr{
nullptr};
193 bool m_deleteSvcOnEnd{
false};
197# if MYNEWT_VAL(BLE_ROLE_CENTRAL)
198# include "NimBLERemoteCharacteristic.h"
200class NimBLEStreamClient :
public NimBLEStream {
202 NimBLEStreamClient() =
default;
203 ~NimBLEStreamClient()
override { end(); }
206 NimBLEStreamClient(
const NimBLEStreamClient&) =
delete;
207 NimBLEStreamClient& operator=(
const NimBLEStreamClient&) =
delete;
211 bool begin(NimBLERemoteCharacteristic* pChr,
212 bool subscribeNotify =
false,
213 uint32_t txBufSize = 1024,
214 uint32_t rxBufSize = 1024);
216 void setNotifyCallback(NimBLERemoteCharacteristic::notify_callback cb) { m_userNotifyCallback = cb; }
217 bool ready()
const override;
218 virtual void flush()
override;
220 using NimBLEStream::write;
223 bool send()
override;
224 void notifyCallback(NimBLERemoteCharacteristic* pChar, uint8_t* pData,
size_t len,
bool isNotify);
226 NimBLERemoteCharacteristic* m_pChr{
nullptr};
227 NimBLERemoteCharacteristic::notify_callback m_userNotifyCallback{
nullptr};
Connection information.
Definition NimBLEConnInfo.h:33
A model of a BLE UUID.
Definition NimBLEUUID.h:41