io.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <span>
#include <type_traits>
#include <utility>
 
#include "tsm/ticks.h"
 
namespace tsm::io {
 
enum class level : unsigned char
{
    low,
    high
};
 
enum class bus_status : unsigned char
{
    ok,
    busy,
    error,
    timeout
};
 
struct digital_input_state
{
    level value{};
};
 
struct adc_sample
{
    std::uint16_t millivolts{};
};
 
struct pwm_duty
{
    std::uint16_t permille{};
};
 
struct can_id
{
    std::uint32_t value{};
    bool extended{};
};
 
struct can_frame
{
    can_id id{};
    std::span<std::byte const> payload{};
};
 
template<typename Awaitable>
concept awaitable = requires(Awaitable awaitable)
{
    {
        awaitable.await_ready()
        } -> std::convertible_to<bool>;
    awaitable.await_resume();
};
 
template<typename Pin>
concept gpio_input = requires(Pin pin)
{
    {
        pin.read()
        } -> std::same_as<level>;
};
 
template<typename Pin>
concept gpio_output = requires(Pin pin, level value)
{
    {
        pin.write(value)
        } -> std::convertible_to<bus_status>;
};
 
template<typename Pin>
concept input_pin = gpio_input<Pin>;
 
template<typename Pin>
concept output_pin = gpio_output<Pin>;
 
template<typename Pin>
concept async_gpio_input = gpio_input<Pin> && requires(Pin pin, level value)
{
    {
        pin.wait_for(value)
        } -> awaitable;
};
 
template<typename Converter>
concept adc = requires(Converter adc)
{
    {
        adc.read()
        } -> std::same_as<adc_sample>;
};
 
template<typename Converter>
concept async_adc = adc<Converter> && requires(Converter adc)
{
    {
        adc.read_async()
        } -> awaitable;
};
 
template<typename Bus>
concept uart = requires(Bus bus,
                        std::span<std::byte> rx,
                        std::span<std::byte const> tx)
{
    {
        bus.read(rx)
        } -> std::convertible_to<bus_status>;
    {
        bus.write(tx)
        } -> std::convertible_to<bus_status>;
};
 
template<typename Bus>
concept async_uart = uart<Bus> &&
  requires(Bus bus, std::span<std::byte> rx, std::span<std::byte const> tx)
{
    {
        bus.read_async(rx)
        } -> awaitable;
    {
        bus.write_async(tx)
        } -> awaitable;
};
 
template<typename Bus>
concept spi = requires(Bus bus,
                       std::span<std::byte const> tx,
                       std::span<std::byte> rx)
{
    {
        bus.transfer(tx, rx)
        } -> std::convertible_to<bus_status>;
};
 
template<typename Bus>
concept async_spi = spi<Bus> &&
  requires(Bus bus, std::span<std::byte const> tx, std::span<std::byte> rx)
{
    {
        bus.transfer_async(tx, rx)
        } -> awaitable;
};
 
template<typename Bus>
concept i2c = requires(Bus bus,
                       std::uint16_t address,
                       std::span<std::byte const> tx,
                       std::span<std::byte> rx)
{
    {
        bus.write(address, tx)
        } -> std::convertible_to<bus_status>;
    {
        bus.read(address, rx)
        } -> std::convertible_to<bus_status>;
};
 
template<typename Bus>
concept async_i2c = i2c<Bus> && requires(Bus bus,
                                         std::uint16_t address,
                                         std::span<std::byte const> tx,
                                         std::span<std::byte> rx)
{
    {
        bus.write_async(address, tx)
        } -> awaitable;
    {
        bus.read_async(address, rx)
        } -> awaitable;
};
 
template<typename Output>
concept pwm = requires(Output output, pwm_duty duty)
{
    {
        output.set_duty(duty)
        } -> std::convertible_to<bus_status>;
    {
        output.enable()
        } -> std::convertible_to<bus_status>;
    {
        output.disable()
        } -> std::convertible_to<bus_status>;
};
 
template<typename Bus>
concept can = requires(Bus bus, can_frame frame, std::span<std::byte> rx)
{
    {
        bus.send(frame)
        } -> std::convertible_to<bus_status>;
    {
        bus.receive(rx)
        } -> std::convertible_to<bus_status>;
};
 
template<typename Bus>
concept async_can = can<Bus> &&
  requires(Bus bus, can_frame frame, std::span<std::byte> rx)
{
    {
        bus.send_async(frame)
        } -> awaitable;
    {
        bus.receive_async(rx)
        } -> awaitable;
};
 
// clang-format off
template<typename Timer>
concept tick_source_rep = requires(Timer timer) {
    { timer.ticks() } -> std::convertible_to<tsm::tick_rep>;
};
 
template<typename Timer>
concept tick_source_duration = requires(Timer timer) {
    { timer.ticks() } -> std::convertible_to<tsm::tick_duration>;
};
// clang-format on
 
template<typename Timer>
concept tick_source = tick_source_rep<Timer> || tick_source_duration<Timer>;
 
template<typename Sink, typename Payload>
concept isr_payload_sink = requires(Sink sink, Payload payload)
{
    {
        sink.try_send_from_isr(std::forward<Payload>(payload))
        } -> std::convertible_to<bool>;
};
 
template<typename Source>
concept isr_notifier = requires(Source source)
{
    source.notify_from_isr();
};
 
template<typename Sink, typename Payload>
requires isr_payload_sink<Sink&, Payload>
[[nodiscard]] bool
push_from_isr(Sink& sink, Payload&& payload)
{
    return sink.try_send_from_isr(std::forward<Payload>(payload));
}
 
template<adc Converter, typename Sink>
requires isr_payload_sink<Sink&, adc_sample>
[[nodiscard]] bool
sample_adc_from_isr(Converter& converter, Sink& sink)
{
    return push_from_isr(sink, converter.read());
}
 
template<gpio_input Pin, typename Sink>
requires isr_payload_sink<Sink&, digital_input_state>
[[nodiscard]] bool
sample_gpio_from_isr(Pin& pin, Sink& sink)
{
    return push_from_isr(sink, digital_input_state{ pin.read() });
}
 
template<isr_notifier Source>
void
notify_from_isr(Source& source)
{
    source.notify_from_isr();
}
 
} // namespace tsm::io