mbed/PluggableUSBMIDI.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Arduino-Wrapper.h>
 
#include <atomic>
#include <cstdint>
#include <tuple>
 
#include <USB/PluggableUSBDevice.h>
#include <drivers/Timeout.h>
#include <platform/Callback.h>
 
#include <AH/Settings/Warnings.hpp>
#include <Settings/NamespaceSettings.hpp>
 
BEGIN_CS_NAMESPACE
 
class PluggableUSBMIDI : protected arduino::internal::PluggableUSBModule {
  public:
    PluggableUSBMIDI();
    ~PluggableUSBMIDI();
 
  public:
    using setup_packet_t = USBDevice::setup_packet_t;
    using DeviceState = USBDevice::DeviceState;
    using microseconds = std::chrono::microseconds;
 
  public:
    bool connected() const;
 
    void write(uint32_t msg);
 
    void write(const uint32_t *msgs, uint32_t num_msgs);
 
    template <size_t N>
    void write(const uint32_t (&msgs)[N]) {
        write(msgs, N);
    }
 
    uint32_t write_nonblock(const uint32_t *msgs, uint32_t num_msgs);
 
    uint32_t read();
 
    void send_now();
 
    void setTimeout(microseconds timeout) {
        writing.timeout_duration = timeout;
    }
    void setErrorTimeout(microseconds timeout) {
        writing.error_timeout_duration = timeout;
    }
 
    uint32_t getWriteError() const { return writing.errors; }
    void clearWriteError() { writing.errors = 0; }
 
  protected:
    void init(EndpointResolver &resolver) override;
    void callback_state_change(DeviceState new_state) override;
    uint32_t callback_request(const setup_packet_t *setup,
                              USBDevice::RequestResult *result,
                              uint8_t **data) override;
    bool callback_request_xfer_done(const setup_packet_t *setup,
                                    bool aborted) override;
    bool callback_set_configuration(uint8_t configuration) override;
    void callback_set_interface(uint16_t interface, uint8_t alternate) override;
 
    const uint8_t *string_iinterface_desc() override;
    const uint8_t *configuration_desc(uint8_t index) override;
    uint8_t getProductVersion() override { return 16; }
 
  protected:
    std::atomic<bool> usb_connected{false};
 
  public:
    static constexpr uint32_t PacketSize = 64;
 
  protected:
    static constexpr uint32_t SizeReserved = PacketSize + 1;
    static constexpr uint32_t NumRxPackets = 2;
 
    struct Reading {
        struct Buffer {
            uint32_t size = 0;
            uint32_t index = 0;
            alignas(uint32_t) uint8_t buffer[PacketSize];
        } buffers[NumRxPackets];
        std::atomic<uint32_t> available{0};
        std::atomic<uint32_t> read_idx{0};
        std::atomic<uint32_t> write_idx{0};
        std::atomic<bool> reading{false};
    } reading;
    using rbuffer_t = std::remove_reference_t<decltype(reading.buffers[0])>;
 
    struct Writing {
        struct Buffer {
            std::atomic<uint32_t> size{0};
            std::atomic<bool> ready_to_send{false};
            alignas(uint32_t) uint8_t buffer[PacketSize];
        } buffers[2];
        std::atomic<uint32_t> active_writebuffer{0};
        std::atomic<Buffer *> sending{nullptr};
        std::atomic<Buffer *> send_timeout{nullptr};
        microseconds timeout_duration{1'000};
        microseconds error_timeout_duration{40'000};
        mbed::Timeout timeout;
        uint32_t errors{0};
    } writing;
    using wbuffer_t = std::remove_reference_t<decltype(writing.buffers[0])>;
 
    usb_ep_t bulk_in_ep;
    usb_ep_t bulk_out_ep;
    uint8_t config_descriptor[0x65];
 
    uint32_t write_impl(const uint32_t *msgs, uint32_t num_msgs,
                        bool nonblocking);
    std::tuple<uint32_t, wbuffer_t *, uint32_t> read_writebuf_size();
    void write_start_sync(uint8_t *buffer, uint32_t size);
    void send_in_callback(uint32_t activebuf_idx);
    bool send_now_impl_nonblock(uint32_t activebuf_idx);
    void timeout_callback();
    void in_callback();
    void out_callback();
};
 
END_CS_NAMESPACE