Line data    Source code

       1              : #pragma once
       2              : 
       3              : #include <AH/Error/Error.hpp>
       4              : 
       5              : #include "BLEAPI.hpp"
       6              : #include "BufferedBLEMIDIParser.hpp"
       7              : #include "ThreadedBLEMIDISender.hpp"
       8              : #include "Util/ESP32Threads.hpp"
       9              : 
      10              : #include <atomic>
      11              : 
      12              : #ifndef ARDUINO
      13              : #define ESP_LOGD(...) ((void)0)
      14              : #define ESP_LOGE(...) ((void)0)
      15              : #define ESP_LOGI(...) ((void)0)
      16              : #endif
      17              : 
      18              : BEGIN_CS_NAMESPACE
      19              : 
      20              : /// ESP32 backend intended to be plugged into @ref GenericBLEMIDI_Interface.
      21              : /// @p Impl can be used to select different low-level BLE stacks.
      22              : template <class Impl>
      23              : class ESP32BLEBackend : private ThreadedBLEMIDISender<ESP32BLEBackend<Impl>>,
      24              :                         private MIDIBLEInstance {
      25              :   protected:
      26              :     [[no_unique_address]] Impl impl;
      27              :     using Sender = ThreadedBLEMIDISender<ESP32BLEBackend>;
      28              :     friend Sender;
      29           22 :     void sendData(BLEDataView data) {
      30           22 :         auto chr = characteristic.load();
      31           22 :         auto con = connection.load();
      32              :         ESP_LOGD("CS-BLEMIDI", "conn=%d, char=%d", con.conn,
      33              :                  chr.characteristic);
      34           22 :         if (chr.characteristic == 0xFFFF)
      35            0 :             return;
      36           22 :         impl.notify(con, chr, data);
      37              :     }
      38              :     std::atomic<BLEConnectionHandle> connection;
      39              :     std::atomic<BLECharacteristicHandle> characteristic;
      40              : 
      41              :   protected:
      42           28 :     void handleConnect(BLEConnectionHandle conn_handle) override {
      43              :         ESP_LOGD("CS-BLEMIDI", "conn=%d", conn_handle.conn);
      44           28 :         this->connection.store(conn_handle);
      45           28 :     }
      46            0 :     void handleDisconnect(
      47              :         [[maybe_unused]] BLEConnectionHandle conn_handle) override {
      48              :         ESP_LOGD("CS-BLEMIDI", "conn=%d", conn_handle.conn);
      49            0 :         this->connection.store({});
      50            0 :         this->characteristic.store({});
      51            0 :     }
      52            0 :     void handleMTU([[maybe_unused]] BLEConnectionHandle conn_handle,
      53              :                    uint16_t mtu) override {
      54              :         ESP_LOGD("CS-BLEMIDI", "conn=%d, mtu=%d", conn_handle.conn, mtu);
      55            0 :         Sender::updateMTU(mtu);
      56            0 :     }
      57           28 :     void handleSubscribe(BLEConnectionHandle conn_handle,
      58              :                          BLECharacteristicHandle char_handle,
      59              :                          bool notify) override {
      60              :         ESP_LOGD("CS-BLEMIDI", "conn=%d, char=%d, notify=%d", conn_handle.conn,
      61              :                  char_handle.characteristic, +notify);
      62           28 :         if (notify) {
      63           28 :             this->connection.store(conn_handle);
      64           28 :             this->characteristic.store(char_handle);
      65              :         } else {
      66            0 :             this->characteristic.store({});
      67              :         }
      68           28 :     }
      69           15 :     void handleData([[maybe_unused]] BLEConnectionHandle conn_handle,
      70              :                     BLEDataGenerator &&data, BLEDataLifetime) override {
      71              :         ESP_LOGD("CS-BLEMIDI", "conn=%d", conn_handle.conn);
      72           15 :         BLEDataView packet = data();
      73           15 :         if (!packet)
      74            0 :             return;
      75           15 :         if (!parser.pushPacket(packet)) {
      76              :             ESP_LOGE("CS-BLEMIDI", "BLE packet dropped, size=%d",
      77              :                      packet.length);
      78            0 :             return;
      79              :         }
      80           15 :         while (BLEDataView cont = data()) {
      81            0 :             if (!parser.pushPacket(cont, BLEDataType::Continuation)) {
      82              :                 ESP_LOGE("CS-BLEMIDI", "BLE chunk dropped, size=%d",
      83              :                          cont.length);
      84            0 :                 return;
      85              :             } else {
      86              :                 ESP_LOGI("CS-BLEMIDI", "added chunk, size=%d", cont.length);
      87              :             }
      88              :         }
      89              :     }
      90              : 
      91              :   private:
      92              :     struct AtomicSize {
      93              : #ifdef ESP32
      94              :         constexpr static size_t alignment = 32; // default cache size
      95              : #else
      96              :         constexpr static size_t alignment = 64;
      97              : #endif
      98           29 :         AtomicSize(uint_fast16_t value) : value {value} {}
      99              :         std::atomic_uint_fast16_t value;
     100           42 :         uint_fast16_t load_acquire() const {
     101           84 :             return value.load(std::memory_order_acquire);
     102              :         }
     103           15 :         void add_release(uint_fast16_t t) {
     104           15 :             value.fetch_add(t, std::memory_order_release);
     105           15 :         }
     106           27 :         void sub_release(uint_fast16_t t) {
     107           27 :             value.fetch_sub(t, std::memory_order_release);
     108           27 :         }
     109              :     };
     110              :     /// Contains incoming BLE MIDI data to be parsed.
     111              :     BufferedBLEMIDIParser<4096, AtomicSize> parser;
     112              : 
     113              :   public:
     114              :     using IncomingMIDIMessage = AnyMIDIMessage;
     115           52 :     bool popMessage(IncomingMIDIMessage &incomingMessage) {
     116           52 :         return parser.popMessage(incomingMessage);
     117              :     }
     118              : 
     119              :   public:
     120           28 :     void begin(BLESettings ble_settings) {
     121           28 :         impl.init(*this, ble_settings);
     122              :         // Need larger stack than default, pin to non-Arduino core
     123           28 :         ScopedThreadConfig sc {4096, 3, true, "CS-BLEMIDI", 0};
     124           28 :         Sender::begin();
     125           28 :     }
     126              :     void end() {
     127              :         FATAL_ERROR(F("ESP32BLEBackend::end not implemented"), 0x3278);
     128              :     }
     129              :     bool isConnected() const {
     130              :         return connection.load(std::memory_order_relaxed).conn != 0xFFFF;
     131              :     }
     132              :     using Sender::acquirePacket;
     133              :     using Sender::forceMinMTU;
     134              :     using Sender::getMinMTU;
     135              :     using Sender::releasePacketAndNotify;
     136              :     using Sender::sendNow;
     137              :     using Sender::setTimeout;
     138              : };
     139              : 
     140              : END_CS_NAMESPACE