template <typename... Args> void sendCommand(std::uint8_t command, Args... commandArgs) noexcept
{
    sendCommand(command);
    sendChunk(static_cast<std::uint8_t>(commandArgs)...);
}
template <typename... Args> void sendChunk(Args... _chunkArgs) noexcept
{
    std::array chunk = {static_cast<std::uint8_t>(_chunkArgs)...};
    Interface::Spi::Transaction chunkTransaction{};
    chunkTransaction.beforeTransaction = [this] { setDcPin(); };
    chunkTransaction.transactionAction = [this, chunkToSend = std::move(chunk)] {
        m_pBusPtr->sendChunk(
            reinterpret_cast<const std::uint8_t*>(chunkToSend.data()), chunkToSend.size());
    };
    chunkTransaction.afterTransaction = [this] { resetDcPin(); };
    m_pBusPtr->addTransaction(std::move(chunkTransaction));
}

sendCommand(DisplayReg::SLPOUT);
sendCommand(DisplayReg::COLMOD, 0x55);
sendCommand(DisplayReg::MADCTL, 0x08);
sendCommand(DisplayReg::CASET, 0x00, 0, 0, 240);

#include <coroutine>
#include <iostream>
struct Awaitable
{
    struct Promise;
    using promise_type = Promise;
    Awaitable(std::coroutine_handle<promise_type> coroHandle) : thisCoroutine{coroHandle}
    {
        std::cout << "Awaitable created\n";
    }
    ~Awaitable()
    {
        std::cout << "Awaitable destroyed\n";
        if (thisCoroutine)
            thisCoroutine.destroy();
    }
    struct Promise
    {
        auto initial_suspend() noexcept
        {
            return std::suspend_always();
        }
        auto final_suspend() noexcept
        {
            return std::suspend_always();
        }
        void unhandled_exception()
        {
            std::terminate();
        }
        Awaitable get_return_object()
        {
            return Awaitable(std::coroutine_handle<promise_type>::from_promise(*this));
        }
        void return_void() noexcept
        {
        }
    };
    bool isFinished()
    {
        if (thisCoroutine)
            return thisCoroutine.done();
        return false;
    }
    void restore()
    {
        if (thisCoroutine && !thisCoroutine.done())
            thisCoroutine.resume();
    }
    std::coroutine_handle<promise_type> thisCoroutine;
};
Awaitable callMe()
{
    std::cout << "Hello ";
    co_await std::suspend_always{};
    std::cout << "World\n";
}
int main()
{
    auto lazyHello = callMe();
    while (!lazyHello.isFinished())
        lazyHello.restore();
    return 0;
}

struct Awaiter
{
    bool resetDcPin = false;
    bool restoreInSpiCtx = false;
    const std::uint8_t* pTransmitBuffer;
    This_t* pBaseDisplay;
    std::uint16_t bufferSize;
    bool await_ready() const noexcept
    {
        // проверяем, есть ли необходимость выполнять приостановку сопрограммы
        const bool isAwaitReady = pTransmitBuffer == nullptr || bufferSize == 0;
        return isAwaitReady;
    }
    void await_resume() const noexcept
    {
        //вызов, который будет совершен при выполнении .resume() у сопрограммы
        if (resetDcPin)
            pBaseDisplay->setDcPin();
    }
    void await_suspend(std::coroutine_handle<> thisCoroutine) const
    {
        //действие на время приостановки сопрограммы. В SPI драйвер передается handle сопрограммы,
        // после чего она приостановлена.
        if (resetDcPin)
            pBaseDisplay->resetDcPin();
        pBaseDisplay->getSpiBus()->transmitBuffer(
            pTransmitBuffer, bufferSize, thisCoroutine.address(), restoreInSpiCtx);
    }
};

void transmitCompleted() noexcept
{
    const bool isAllDmaTransactionsProceeded = m_transmitContext.fullDmaTransactionsCount == 0;
    const bool isAllChunckedTransactionsCompleted =
        m_transmitContext.chunkedTransactionBufSize == 0;
    if (!isAllDmaTransactionsProceeded)
    {
        //Если еще можем передавать транзакции размером с DMA буфер
    }
    else if (!isAllChunckedTransactionsCompleted)
    {
        // Если транзакции меньше размера DMA буфера не переданы
    }
    else
    {
        // В случае, если все DMA транзакции выполнены- проверяем, в каком контексте выполнения
        // должна быть восстановлена сопрограмма.Не забываем, что этот метод вызывается из контекта
        // прерывания и восстановление тяжелой сопрограммы может привести к трудноулавливааемым
        // ошибкам. Тут есть два варианта - либо восстанавливаемся в контекте прерывания, либо
        // передаем обработчик сопрограммы в очередь,которая обрабатывается в главном потоке. Таким
        // образом, сопрограмма будет восстановлена из main-потока.
        if (m_transmitContext.restoreInSpiCtx)
        {
            m_coroHandle.resume();
        }
        else
        {
            CoroUtils::CoroQueueMainLoop::GetInstance().pushToLater(m_coroHandle);
        }
    }
}

auto sendCommand(const std::uint8_t* pBuffer, std::size_t bufferSize) noexcept
{
    const std::uint8_t* commandBuf = pBuffer;
    const std::uint8_t* ArgBuf = pBuffer + 1;
    const std::uint16_t ArgsBufferSize = static_cast<std::uint16_t>(bufferSize - 1);
    return CoroUtils::when_all_sequence(
        sendCommandImpl(commandBuf),
        ArgsBufferSize > 0 ? sendChunk(ArgBuf, ArgsBufferSize) : sendChunk(nullptr, 0));
}
auto sendChunk(const std::uint8_t* pBuffer, std::size_t bufferSize) noexcept
{
    return Awaiter{.pTransmitBuffer = pBuffer,
                   .pBaseDisplay = this,
                   .bufferSize = static_cast<std::uint16_t>(bufferSize)};
}

namespace DisplayDriver::InitializationCommands
{
// clang-format off
constexpr std::size_t CommandsSize = 328;
constexpr std::size_t CommandsTransactionsCount = 59;
static auto Commands = std::array<std::uint8_t, CommandsSize>
{
    /***Cmd****Argc****delay****argv*****************************/
        0xFE,   0,      0
    ,   0xEF,   0,      0
    ,   0xEB,   1,      0,      0x14
    ,   0xFE,   0,      0
    ,   0xEF,   0,      0
    ,   0xEB,   1,      0,      0x14
    ,   0xFE,   0,      0
    ,   0xEF,   0,      0
    ,   0xEB,   1,      0,      0x14
    .....
}
// clang-format on
} // namespace DisplayDriver::InitializationCommands

void initDisplay() noexcept
{
    TBaseSpiDisplay::resetResetPin();
    Delay::waitFor(100);
    TBaseSpiDisplay::setResetPin();
    size_t CommandCount = InitializationCommands::CommandsTransactionsCount;
    const std::uint8_t* pBuffer = InitializationCommands::Commands.data();
    while (CommandCount--)
    {
        const std::uint8_t* Command = pBuffer++;
        const std::uint8_t NumArgs = *pBuffer++;
        const std::uint8_t Delay = *pBuffer++;
        co_await TBaseSpiDisplay::sendCommandImpl(Command);
        if (NumArgs)
        {
            co_await TBaseSpiDisplay::sendChunk(pBuffer++, NumArgs);
            pBuffer += (NumArgs - 1);
        }
        if (Delay)
            Delay::waitFor(Delay);
    }
    TBaseSpiDisplay::m_displayInitialized.set();
}

void fillRectangle(
    std::uint16_t x,
    std::uint16_t y,
    std::uint16_t width,
    std::uint16_t height,
    TBaseSpiDisplay::TColor* colorToFill) noexcept
{
    const std::uint16_t DisplayHeight = TBaseSpiDisplay::getHeight();
    const std::uint16_t DisplayWidth = TBaseSpiDisplay::getWidth();
    const bool isCoordsValid{!((x >= DisplayWidth) || (y >= DisplayHeight))};
    if (isCoordsValid)
    {
        //Определяем размеры буфера для отправки
        const size_t BytesSizeX = (width - x + 1);
        const size_t BytesSizeY = (height - y + 1);
        const size_t BytesSquare = BytesSizeX * BytesSizeY;
        const size_t TransferBufferSize = (BytesSquare * sizeof(typename TBaseSpiDisplay::TColor));
        //Формируем область экрана для обновления
        setAddrWindow(x, y, width, height);
        static std::uint8_t RamWriteCmd{0x2C};
        // Команда на запись в экранный буфер
        TBaseSpiDisplay::sendCommandImplFast(&RamWriteCmd);
        //Устанавликаем порт Data/Command в режим работы с данными(все что передано в дисплей
        //воспринимается, как данные, а не как команды)
        TBaseSpiDisplay::setDcPin();
        // Отправляем дисплейный буфер
        TBaseSpiDisplay::sendChunk(
            reinterpret_cast<const std::uint8_t*>(colorToFill), TransferBufferSize);
        // Восстанавливаем состояние порта Data/Command
        TBaseSpiDisplay::resetDcPin();
        // Сигнализируем об окончании заполнении области дисплея
        TBaseSpiDisplay::onRectArreaFilled.emitLater();
    }
}

//Формируем область экрана для обновления
co_await setAddrWindow(x, y, width, height); // <=============== co_await here
static std::uint8_t RamWriteCmd{0x2C};
// Команда на запись в экранный буфер
co_await TBaseSpiDisplay::sendCommandImplFast(&RamWriteCmd); // <=============== co_await here
TBaseSpiDisplay::setDcPin();
// Отправляем дисплейный буфер
co_await TBaseSpiDisplay::sendChunk(
    reinterpret_cast<const std::uint8_t*>(colorToFill),
    TransferBufferSize); // <=============== co_await here
TBaseSpiDisplay::resetDcPin();
TBaseSpiDisplay::onRectArreaFilled.emitLater();

template <std::uint8_t... Command> struct CommandDescriptor
{
};
template <std::uint8_t Command, std::uint8_t CommandDelay, std::uint8_t... CommandArgs>
struct CommandDescriptor<Command, CommandDelay, CommandArgs...>
{
    std::uint8_t commandDelay = CommandDelay;
    std::array<std::uint8_t, sizeof...(CommandArgs) + 1> command{Command, CommandArgs...};
};
template <std::uint8_t Command, std::uint8_t CommandDelay>
struct CommandDescriptor<Command, CommandDelay>
{
    std::uint8_t commandDelay = CommandDelay;
    std::array<std::uint8_t, 1> command{Command};
};
template <std::uint8_t Command> struct CommandDescriptor<Command>
{
    std::uint8_t commandDelay = 0;
    std::array<std::uint8_t, 1> command{Command};
};

static std::tuple CommandsArray = {
    CommandDescriptor<0xFE>{},
    CommandDescriptor<0xEF>{},
    CommandDescriptor<0xEB, DefaultDelay, 0x14>{},
    CommandDescriptor<0xFF, DefaultDelay, 0x60, 0x01, 0x04>{},
    CommandDescriptor<0x74, DefaultDelay, 0x10, 0x75, 0x80, 0x00, 0x00, 0x4E, 0x00>{},
    CommandDescriptor<0xC3, DefaultDelay, 0x14, 0xC4, 0x14, 0xC9, 0x25>{},
    CommandDescriptor<0x74, DefaultDelay, 0x10, 0x85, 0x80, 0x00, 0x00, 0x4e, 0x00>{},
    CommandDescriptor<0x29>{}};

template <typename Tuple, std::size_t... Indexes>
CoroUtils::VoidTask launchInit(
    Tuple&& commandSequence,
    std::integer_sequence<std::size_t, Indexes...>) noexcept
{
    (co_await CoroUtils::when_all_sequence(sendCommand(
         std::get<Indexes>(commandSequence).command.data(),
         std::get<Indexes>(commandSequence).command.size())),
     ...);
}

static std::array xAxisCommand = std::array{static_cast<std::uint8_t>(0x2a),
                                            static_cast<std::uint8_t>(xa >> 24),
                                            static_cast<std::uint8_t>(xa >> 16),
                                            static_cast<std::uint8_t>(xa >> 8),
                                            static_cast<std::uint8_t>(xa)};
static std::array yAxisCommand = std::array{static_cast<std::uint8_t>(0x2b),
                                            static_cast<std::uint8_t>(ya >> 24),
                                            static_cast<std::uint8_t>(ya >> 16),
                                            static_cast<std::uint8_t>(ya >> 8),
                                            static_cast<std::uint8_t>(ya)};
co_await sendCommand(xAxisCommand.data(), xAxisCommand.size());
co_await sendCommand(yAxisCommand.data(), yAxisCommand.size());

template <typename... Tasks> struct WhenAllSequence {
  //  Хранилище переданных задач
  std::tuple<Tasks...> m_taskList;
  explicit WhenAllSequence(Tasks &&... tasks) noexcept
      : m_taskList(std::move(tasks)...) {}
  explicit WhenAllSequence(std::tuple<Tasks...> &&tasks) noexcept
      : m_taskList(std::move(tasks)) {}
  bool await_ready() const noexcept {
    //Возвращаем false, т.к. вызов await_suspend долежн быть выполнен. Если
    //вернуть true- приостановка сопрограммы выполнена не будет, тело
    //await_suspend вызвано не будет.
    return false;
  }
  void await_suspend(stdcoro::coroutine_handle<> handle) noexcept {
    // при вызове co_await будет выполнен вызов launchAll, в котором компиляторм
    // для каждого элемента std::tuple был сгенериррован вызов co_await
    co_await launchAll(
        std::make_integer_sequence<std::size_t, sizeof...(Tasks)>{});
    handle.resume();
  }
  template <std::size_t... Indexes>
  VoidTask launchAll(std::integer_sequence<std::size_t, Indexes...>) {
    // Используя fold-expression из C++17 - вызываем co_await для каждого
    // элемента tuple
    (co_await std::get<Indexes>(m_taskList), ...);
  }
  void await_resume() noexcept {}
};
template <typename... Args> auto when_all_sequence(Args &&... args) noexcept {
  // конструируем WhenAllSequence от переданных аргументов, при этом из
  // аргументов формируем tuple.
  return WhenAllSequence{std::make_tuple(std::move(args)...)};
}
} // namespace CoroUtils

VoidTask lazyTask()
{
    std::cout<<"I was called\n";
    co_return;
}
int main()
{
    auto lazy = lazyTask();
    return 0;
}

Start
0
Finish

struct Promise
{
    auto initial_suspend() noexcept
    {
        return std::suspend_never{};
    }
    auto final_suspend() noexcept
    {
        return std::suspend_never{};
    }
void get_return_object()
{
}
void return_void()
{
}
void unhandled_exception()
{
    while (1)
    {
    }
}
};
template <typename... Args> struct std::coroutine_traits<void, Args...>
{
    using promise_type = Promise;
};
void taskEval()
{
    auto lazy = lazyTask();
    co_await lazy;
}
int main()
{    taskEval();
    return 0;
}

struct task_promise
    {
        task_promise() noexcept = default;
        void return_void() noexcept
        {
        }
        void unhandled_exception() noexcept
        {
            std::terminate();
        }
        VoidTask get_return_object() noexcept
        {
            return VoidTask{std::coroutine_handle<task_promise>::from_promise(*this)};
        }
        auto initial_suspend() noexcept
        {
            return std::suspend_always{};
        }
    };

struct task_awaitable
    {
        task_awaitable(std::coroutine_handle<promise_type> coroutine) : m_coroutine{coroutine}
        {
        }
        bool await_ready() const noexcept
        {
            return !m_coroutine || m_coroutine.done();
        }
        auto await_suspend(std::coroutine_handle<> awaitingRoutine)
        {
            // Используем symmetric-transfer
            // Подробнее можно ознакомиться:
            // https://lewissbaker.github.io/2020/05/11/understanding_symmetric_transfer
            m_coroutine.promise().set_continuation(awaitingRoutine);
            return m_coroutine;
        }
        void await_resume()
        {
        }
        std::coroutine_handle<promise_type> m_coroutine;
    };

void set_continuation(std::coroutine_handle<> continuation)
{
    m_continuation = continuation;
}

struct final_awaitable
{
    bool await_ready() noexcept
    {
        return false;
    }
    template <typename TPromise>
    auto await_suspend(std::coroutine_handle<TPromise> coroutine) noexcept
    {
        task_promise& promise = coroutine.promise();
        return promise.m_continuation;
    }
void await_resume() noexcept
{
}
};

#include <coroutine>
#include <iostream>
struct VoidTask
{
    struct task_promise;
    using promise_type = task_promise;
struct task_promise
{
    task_promise() noexcept = default;
    //Сопрограмма ничего не возвращает. return_void
    void return_void() noexcept
    {
    }
    // При перехвате необработанного исключения - std::terminate
    void unhandled_exception() noexcept
    {
        std::terminate();
    }
    //Возвращаемый на вызывающую сторону объект - VoidTask с переданным в конструктор
    //coroutine_handle
    VoidTask get_return_object() noexcept
    {
        return VoidTask{std::coroutine_handle<task_promise>::from_promise(*this)};
    }
    // Изначально сопрограмма приостановлена
    auto initial_suspend() noexcept
    {
        return std::suspend_always{};
    }
    struct final_awaitable
    {
        bool await_ready() noexcept
        {
            // await_ready - false, вызов тела await_suspend является необходимым
            return false;
        }
        template <typename TPromise>
        auto await_suspend(std::coroutine_handle<TPromise> coroutine) noexcept
        {
            // https://lewissbaker.github.io/2020/05/11/understanding_symmetric_transfer
            task_promise& promise = coroutine.promise();
            return promise.m_continuation;
        }
        void await_resume() noexcept
        {
        }
    };
    void set_continuation(std::coroutine_handle<> continuation)
    {
        m_continuation = continuation;
    }
    auto final_suspend() noexcept
    {
        return final_awaitable{};
    }
    std::coroutine_handle<> m_continuation;
};
struct task_awaitable
{
    task_awaitable(std::coroutine_handle<promise_type> coroutine) : m_coroutine{coroutine}
    {
    }
    bool await_ready() const noexcept
    {
        return !m_coroutine || m_coroutine.done();
    }
    auto await_suspend(std::coroutine_handle<> awaitingRoutine)
    {
        m_coroutine.promise().set_continuation(awaitingRoutine);
        return m_coroutine;
    }
    void await_resume()
    {
    }
    std::coroutine_handle<promise_type> m_coroutine;
};
VoidTask(std::coroutine_handle<task_promise> suspendedCoroutine)
    : m_coroutine{suspendedCoroutine}
{
}
~VoidTask()
{
    // т.к. мы возвращали для initial_suspend у promise_type std::suspend_always -
    // ответственность за удаление coroutine handle остается на нас.
    if (m_coroutine)
        m_coroutine.destroy();
}
bool await_ready() const noexcept
{
    return !m_coroutine || m_coroutine.done();
}
auto operator co_await() noexcept
{
    return task_awaitable{m_coroutine};
}
void await_resume()
{
}
std::coroutine_handle<promise_type> m_coroutine;
};

void transmitBuffer(
    const std::uint8_t* pBuffer,
    std::uint16_t pBufferSize,
    void* pUserData,
    bool restoreInSpiCtx) noexcept
{
    // установили coroutine_handle
    m_coroHandle = std::coroutine_handle<>::from_address(pUserData);
    //установили вызов, который будет вызван по окончанию передачи в конкретной реализации SPI
    m_backendImpl.setTransactionCompletedHandler([this] { transmitCompleted(); });
    const size_t TransferBufferSize = pBufferSize;
    const size_t FullDmaTransactionsCount = TransferBufferSize / DmaBufferSize;
    const size_t ChunkedTransactionsBufSize = TransferBufferSize % DmaBufferSize;
    const bool ComputeChunkOffsetWithDma = FullDmaTransactionsCount >= 1;
    // сформировали контекст транзакции
    TransactionContext newContext{.restoreInSpiCtx = restoreInSpiCtx,
                                  .computeChunkOffsetWithDma = ComputeChunkOffsetWithDma,
                                  .pDataToTransmit = pBuffer,
                                  .fullDmaTransactionsCount = FullDmaTransactionsCount,
                                  .chunkedTransactionBufSize = ChunkedTransactionsBufSize,
                                  .completedTransactionsCount = 0};
    m_transmitContext = std::move(newContext);
    // выполнили передачу данных
    if (FullDmaTransactionsCount)
    {
        --m_transmitContext.fullDmaTransactionsCount;
        m_backendImpl.sendChunk(pBuffer, DmaBufferSize);
    }
    else
    {
        m_transmitContext.chunkedTransactionBufSize = 0;
        m_backendImpl.sendChunk(pBuffer, pBufferSize);
    }
}

template <typename PeripheralInstance> class NordicSpi
{
public:
    using This_t = NordicSpi<PeripheralInstance>;
    NordicSpi() noexcept
    {
        nrfx_spim_config_t spiConfig{};
        // конфигурация SPI пропущена .... //
        //инициализация модуля SPIM. если вместо spimEventHandlerThisOne и this передать nullptr и
        //nullptr - передача будет выполнена без использования EasyDMA, т.е. в блокирующем режиме
        APP_ERROR_CHECK(nrfx_spim_init(
            &SpiInstance::HandleStorage[PeripheralInstance::HandleIdx],
            &spiConfig,
            spimEventHandlerThisOne,
            this));
    }
    void sendChunk(const std::uint8_t* pBuffer, const size_t bufferSize) noexcept
    {
        // формирование дескриптора на передачу данных
        nrfx_spimxfer_desc_t xferDesc = NRFX_SPIMXFER_TX(pBuffer, bufferSize);
        // выполнение транзакции
        nrfx_err_t transmissionError = nrfx_spimxfer(
            &SpiInstance::HandleStorage[PeripheralInstance::HandleIdx], &xferDesc, 0);
        APP_ERROR_CHECK(transmissionError);
    }
    void xferChunk(
        std::span<const std::uint8_t> _transmitArray,
        std::span<std::uint8_t> _receiveArray)
    {
        // формирование transmit-receive транзакции
        nrfx_spimxfer_desc_t xferDesc = NRFX_SPIMXFER_TRX(
            _transmitArray.data(),
            _transmitArray.size(),
            _receiveArray.data(),
            _receiveArray.size());
        nrfx_err_t transmissionError = nrfx_spimxfer(
            &SpiInstance::HandleStorage[PeripheralInstance::HandleIdx], &xferDesc, 0);
        APP_ERROR_CHECK(transmissionError);
    }
    using TTransactionCompletedHandler = std::function<void()>;
    void setTransactionCompletedHandler(const TTransactionCompletedHandler& _handler) noexcept
    {
        m_transactionCompleted = _handler;
    }
private:
    static void spimEventHandlerThisOne(nrfx_spim_evt_t const* _pEvent, void* _pContext) noexcept
    {
        // данный обработчик вызывается по окончании передачи данных при помощи EasyDMA
        if (_pEvent->type == NRFX_SPIM_EVENT_DONE)
        {
            // вызываем ранее установленный callback на драйвере верхнего уровня.
            auto pThis = reinterpret_cast<This_t*>(_pContext);
            pThis->m_transactionCompleted();
        }
    }
public:
    TTransactionCompletedHandler m_transactionCompleted;
};

public ::testing::WithParamInterface<std::tuple<std::uint16_t, std::string_view>>

void sendChunk(const std::uint8_t* pBuffer, const size_t bufferSize) noexcept
{
    BusTransactionsTransmit.emplace_back(pBuffer, bufferSize);
    m_completedTransaction();
}
using TDataStream = std::vector<std::byte>;
TDataStream getTransmittedData() const
{
    TDataStream stream;
    std::ranges::for_each(BusTransactionsTransmit, [&stream](const auto& _transaction) {
        const auto& [pArray, blockSize] = _transaction;
        auto arraySpan = std::span{pArray, blockSize};
        std::ranges::transform(arraySpan, std::back_inserter(stream), [](std::uint8_t _dataByte) {
            return std::byte{_dataByte};
        });
    });
    return stream;
}

TEST_P(SpiDriverTest, CheckRandomSequenceWithLengthTransmissionCorrect)
{
    // получаем размер последовательности
    const std::uint16_t TransactionLength{std::get<0>(GetParam())};
    TDataStream ExpectedStream{TransactionLength};
    std::random_device randomDevice;
    std::mt19937 generator(randomDevice());
    std::uniform_int_distribution<> distribution(0x00, 0xFF);
    // формируем случайную посылку
    std::ranges::generate(ExpectedStream, [&distribution, generator]() mutable {
        return std::byte(distribution(generator));
    });
    CoroUtils::syncWait(sendChunk(
        reinterpret_cast<const std::uint8_t*>(ExpectedStream.data()), ExpectedStream.size()));
    // проверяем соответствие данных, которые должны были быть переданы данным, которые были отправлены в spi-backend
    EXPECT_EQ(TransactionsToDataStream(), ExpectedStream);
}

INSTANTIATE_TEST_SUITE_P(
    SpiDriverTesting,
    SpiDriverTest,
    ::testing::Values(
        std::make_tuple(Null, "Null"),
        std::make_tuple(SmallerThanSingleDmaTransaction, "SmallerThanSingleDmaTransaction"),
        std::make_tuple(EqualsToSingleDmaTransaction, "EqualsToSingleDmaTransaction"),
        std::make_tuple(ThreeDmaTransactions, "ThreeDmaTransactions"),
        std::make_tuple(SingleDmaAndChunk, "SingleDmaAndChunk"),
        std::make_tuple(ThreeDmaAndChunk, "ThreeDmaAndChunk"),
        std::make_tuple(StressChunked, "StressChunked")),
    [](const auto& testParam) {
        const auto& suiteName = std::get<1>(testParam.param);
        return std::string(suiteName.data());
    });

void Board::initBoardSpiFlash() noexcept
{
    m_pFlashDriver = std::make_unique<Hal::TFlashDriver>();
    if (m_pFlashDriver)
    {
        const std::uint32_t JedecId = co_await m_pFlashDriver->requestJEDEDCId();
        LOG_DEBUG("Jedec Id is:");
        LOG_DEBUG_ENDL(fmt::format("{:#04x}", JedecId));
        const std::span<std::uint8_t> DeviceId = co_await m_pFlashDriver->requestDeviceId();
        LOG_DEBUG_ENDL(fmt::format("{:02X}", fmt::join(DeviceId, "")));
    }
}

decltype(auto) await_resume()
{
    return m_coroutine.promise().result();
}

TResult& result()
{
    return m_coroutineResult;
}

void return_value(const TResult& _value)noexcept
{
    m_coroutineResult = _value;
}

template <typename TResult> struct Task

struct ResultTaskPromise
{
    ResultTaskPromise() noexcept = default;
    void unhandled_exception() noexcept
    {
        std::terminate();
    }
    Task<TResult> get_return_object() noexcept
    {
        // Изменили тип возвращаемого объекта, теперь это шаблонный Task<Result>
        return Task<TResult>{std::coroutine_handle<ResultTaskPromise>::from_promise(*this)};
    }
    auto initial_suspend() noexcept
    {
        return std::suspend_always{};
    }
    void return_value(const TResult& _value) noexcept
    {
        // добавили метод return value
        m_coroutineResult = _value;
    }
    void set_continuation(std::coroutine_handle<> continuation)
    {
        m_continuation = continuation;
    }
    TResult& result()
    {
        // добавили метод result для возвращения результата
        return m_coroutineResult;
    }
    struct final_awaitable
    {
        bool await_ready() noexcept
        {
            return false;
        }
        template <typename TPromise>
        void await_suspend(std::coroutine_handle<TPromise> coroutine) noexcept
        {
            ResultTaskPromise& promise = coroutine.promise();
            if (promise.m_continuation)
            {
                promise.m_continuation.resume();
            }
        }
        void await_resume() noexcept
        {
        }
    };
    auto final_suspend() noexcept
    {
        return final_awaitable{};
    }
    // добавили поле класса для хранения результата
    TResult m_coroutineResult;
    std::coroutine_handle<> m_continuation;
};

CoroUtils::Task<std::uint32_t> requestJEDEDCId() noexcept
{
    auto receivedData = co_await prepareXferTransaction(
        std::forward_as_tuple(WindbondCommandSet::ReadJedecId),
        WindbondCommandSet::DummyByte,
        WindbondCommandSet::DummyByte,
        WindbondCommandSet::DummyByte);
    std::uint32_t JedecDeviceId{};
    for (std::size_t i{}; i < WindbondCommandSet::JedecIdLength; ++i)
    {
        JedecDeviceId |= (receivedData[i] << (16 - i * 8));
    }
    co_return JedecDeviceId;
}

template <typename TCommand, typename... Args>
    CoroUtils::Task<std::span<std::uint8_t>> prepareXferTransaction(
        TCommand&& command,
        Args&&... argList)
    {
        auto& transmitBuffer = getSpiBus()->getDmaBufferTransmit();
        auto& receiveBuffer = getSpiBus()->getDmaBufferReceive();
        getSpiBus()->setCsPinLow();
        processTransmitBuffer(transmitBuffer, std::forward<TCommand&&>(command));
        constexpr std::size_t CommandSize = std::tuple_size_v<TCommand>;
        co_await transmitChunk(std::span(transmitBuffer.data(), CommandSize));
        constexpr std::size_t DummyListSize = sizeof...(argList);
        processTransmitBuffer(transmitBuffer, std::forward_as_tuple(argList...));
        auto receivedBlockSpan = co_await xferTransaction(
            std::span(transmitBuffer.data(), DummyListSize),
            std::span(receiveBuffer.data(), DummyListSize));
        getSpiBus()->setCsPinHigh();
        co_return std::span(receiveBuffer.data(), DummyListSize);
    }

TEST_F(FlashDriverTest, RequestJedecId)
{
    auto jedecId = CoroUtils::syncWait(flashDriver.requestJEDEDCId());
    constexpr std::uint32_t MagicTrashFromRawMemory = 13487565; //  For fun;
    EXPECT_EQ(jedecId, MagicTrashFromRawMemory);
}

template <typename TCoroutine>
auto syncWait(TCoroutine&& _coroutineTask)->//Необходимо получить возвращаемый тип

template <typename TAwaiter> auto awaiterGetter(TAwaiter&& _awaiter)
{
    return static_cast<TAwaiter&&>(_awaiter).operator co_await();
}
template <typename TAwaitable> struct AwaitResultGetter
{
    using Type = decltype(awaiterGetter(std::declval<TAwaitable>()));
    using Result = decltype(std::declval<Type>().await_resume());
};

template <typename TAwaitable, typename TTaskResult = AwaitResultGetter<TAwaitable>::Result>
SyncWaitTask<TTaskResult> makeSyncWaitTask(TAwaitable&& awaitable)
{
    co_yield co_await awaitable;
}

class BlockingEvent
{
public:
    void wait()
    {
        std::unique_lock<std::mutex> lock(mutex);
        condEvent.wait(lock, [this] { return m_isSet.load(std::memory_order_acquire); });
    }
void set()
{
    m_isSet.store(true, std::memory_order_release);
    condEvent.notify_all();
}
private:
    std::atomic_bool m_isSet = false;
    std::mutex mutex;
    std::condition_variable condEvent;
};

template<typename TResultType>
struct SyncTaskPromise;
template <typename TResultType>
struct SyncWaitTask
{
    using promise_type = SyncTaskPromise<TResultType>;
    using TResultRef = ResultTypeRefHolder<TResultType>::Type;
    SyncWaitTask(stdcoro::coroutine_handle<SyncTaskPromise<TResultType>> suspendedRoutine)
        : m_suspendedRoutine{suspendedRoutine}
    {
    }
    ~SyncWaitTask()
    {
        if (m_suspendedRoutine)
            m_suspendedRoutine.destroy();
    }
    decltype(auto) result() noexcept
    {
        return m_suspendedRoutine.promise().value();
    }
    void await_resume()
    {
    }
    void start(BlockingEvent& _event)
    {
        m_suspendedRoutine.promise().start(&_event);
    }
    stdcoro::coroutine_handle<SyncTaskPromise<TResultType>> m_suspendedRoutine;
};
template<typename TResultType>
struct SyncTaskPromise
{
    using TResultRef = TResultType&&;
    struct FinalAwaitable
    {
        bool await_ready() noexcept
        {
            return false;
        }
        template <typename TPromise>
        void await_suspend(stdcoro::coroutine_handle<TPromise> coroutine) noexcept
        {
            SyncTaskPromise& promise = coroutine.promise();
            promise.m_event->set();
        }
        void await_resume() noexcept
        {
        }
    };
    auto get_return_object() noexcept
    {
        return SyncWaitTask<TResultType>{ stdcoro::coroutine_handle<SyncTaskPromise<TResultType>>::from_promise(*this) };
    }
    void start(BlockingEvent* _pEvent) noexcept
    {
        m_event = _pEvent;
        stdcoro::coroutine_handle<SyncTaskPromise<TResultType>>::from_promise(*this).resume();
    }
    auto initial_suspend() noexcept
    {
        return std::suspend_always{};
    }
    auto final_suspend() noexcept
    {
        return FinalAwaitable{};
    }
    auto yield_value(TResultRef result) noexcept
    {
        m_value = std::addressof(result);
        return final_suspend();
    }
    decltype(auto) value() noexcept
    {
        return static_cast<TResultRef>(*m_value);
    }
    void return_void() noexcept
    {
    }
    void unhandled_exception()
    {
        std::terminate();
    }
    BlockingEvent* m_event;
    std::remove_reference_t<TResultType>* m_value;
};
template <typename TAwaitable, typename TTaskResult = AwaitResultGetter<TAwaitable>::Result>
SyncWaitTask<TTaskResult> makeSyncWaitTask(TAwaitable&& awaitable)
{
    if constexpr (!std::is_same_v<TTaskResult, void>)
        co_yield co_await awaitable;
    else
        co_await awaitable;
}