tsm::io Namespace Reference

Classes
struct	digital_input_state
struct	adc_sample
struct	pwm_duty
struct	can_id
struct	can_frame

Enumerations
enum class	level : unsigned char { low , high }
enum class	bus_status : unsigned char { ok , busy , error , timeout }

Functions
template<typename Sink , typename Payload >
requires isr_payload_sink< Sink &, Payload > bool	push_from_isr (Sink &sink, Payload &&payload)
template<adc Converter, typename Sink >
requires isr_payload_sink< Sink &, adc_sample > bool	sample_adc_from_isr (Converter &converter, Sink &sink)
template<gpio_input Pin, typename Sink >
requires isr_payload_sink< Sink &, digital_input_state > bool	sample_gpio_from_isr (Pin &pin, Sink &sink)
template<isr_notifier Source>
void	notify_from_isr (Source &source)

Variables
template<typename Awaitable >
concept	awaitable
template<typename Pin >
concept	gpio_input
template<typename Pin >
concept	gpio_output
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
template<typename Converter >
concept	adc
template<typename Converter >
concept	async_adc
template<typename Bus >
concept	uart
template<typename Bus >
concept	async_uart
template<typename Bus >
concept	spi
template<typename Bus >
concept	async_spi
template<typename Bus >
concept	i2c
template<typename Bus >
concept	async_i2c
template<typename Output >
concept	pwm
template<typename Bus >
concept	can
template<typename Bus >
concept	async_can
template<typename Timer >
concept	tick_source_rep
template<typename Timer >
concept	tick_source_duration
template<typename Timer >
concept	tick_source = tick_source_rep<Timer> || tick_source_duration<Timer>
template<typename Sink , typename Payload >
concept	isr_payload_sink
template<typename Source >
concept	isr_notifier

Enumeration Type Documentation

bus_status

enum tsm::io::bus_status : unsigned char

strong

Enumerator
ok
busy
error
timeout

level

enum tsm::io::level : unsigned char

strong

Enumerator
low
high

Function Documentation

notify_from_isr()

template<isr_notifier Source>

void tsm::io::notify_from_isr

(

Source &

source

)

push_from_isr()

template<typename Sink , typename Payload >

requires isr_payload_sink<Sink&, Payload> bool tsm::io::push_from_isr	(	Sink &	sink,
		Payload &&	payload
	)

sample_adc_from_isr()

template<adc Converter, typename Sink >

requires isr_payload_sink<Sink&, adc_sample> bool tsm::io::sample_adc_from_isr	(	Converter &	converter,
		Sink &	sink
	)

sample_gpio_from_isr()

template<gpio_input Pin, typename Sink >

requires isr_payload_sink<Sink&, digital_input_state> bool tsm::io::sample_gpio_from_isr	(	Pin &	pin,
		Sink &	sink
	)

Variable Documentation

adc

template<typename Converter >

concept tsm::io::adc

Initial value:

= requires(Converter adc)
{
    {
        adc.read()
        } -> std::same_as<adc_sample>;
}

async_adc

template<typename Converter >

concept tsm::io::async_adc

Initial value:

= adc<Converter> && requires(Converter adc)
{
    {
        adc.read_async()
        } -> awaitable;
}

async_can

template<typename Bus >

concept tsm::io::async_can

Initial value:

= can<Bus> &&
  requires(Bus bus, can_frame frame, std::span<std::byte> rx)
{
    {
        bus.send_async(frame)
        } -> awaitable;
    {
        bus.receive_async(rx)
        } -> awaitable;
}

async_gpio_input

template<typename Pin >

concept tsm::io::async_gpio_input

Initial value:

= gpio_input<Pin> && requires(Pin pin, level value)
{
    {
        pin.wait_for(value)
        } -> awaitable;
}

async_i2c

template<typename Bus >

concept tsm::io::async_i2c

Initial value:

= 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;
}

async_spi

template<typename Bus >

concept tsm::io::async_spi

Initial value:

= spi<Bus> &&
  requires(Bus bus, std::span<std::byte const> tx, std::span<std::byte> rx)
{
    {
        bus.transfer_async(tx, rx)
        } -> awaitable;
}

async_uart

template<typename Bus >

concept tsm::io::async_uart

Initial value:

= 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;
}

awaitable

template<typename Awaitable >

concept tsm::io::awaitable

Initial value:

= requires(Awaitable awaitable)
{
    {
        awaitable.await_ready()
        } -> std::convertible_to<bool>;
    awaitable.await_resume();
}

can

template<typename Bus >

concept tsm::io::can

Initial value:

= 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>;
}

gpio_input

template<typename Pin >

concept tsm::io::gpio_input

Initial value:

= requires(Pin pin)
{
    {
        pin.read()
        } -> std::same_as<level>;
}

gpio_output

template<typename Pin >

concept tsm::io::gpio_output

Initial value:

= requires(Pin pin, level value)
{
    {
        pin.write(value)
        } -> std::convertible_to<bus_status>;
}

i2c

template<typename Bus >

concept tsm::io::i2c

Initial value:

= 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>;
}

input_pin

template<typename Pin >

concept tsm::io::input_pin = gpio_input<Pin>

isr_notifier

template<typename Source >

concept tsm::io::isr_notifier

Initial value:

= requires(Source source)
{
    source.notify_from_isr();
}

isr_payload_sink

template<typename Sink , typename Payload >

concept tsm::io::isr_payload_sink

Initial value:

= requires(Sink sink, Payload payload)
{
    {
        sink.try_send_from_isr(std::forward<Payload>(payload))
        } -> std::convertible_to<bool>;
}

output_pin

template<typename Pin >

concept tsm::io::output_pin = gpio_output<Pin>

pwm

template<typename Output >

concept tsm::io::pwm

Initial value:

= 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>;
}

spi

template<typename Bus >

concept tsm::io::spi

Initial value:

= requires(Bus bus,
                       std::span<std::byte const> tx,
                       std::span<std::byte> rx)
{
    {
        bus.transfer(tx, rx)
        } -> std::convertible_to<bus_status>;
}

tick_source

template<typename Timer >

concept tsm::io::tick_source = tick_source_rep<Timer> || tick_source_duration<Timer>

tick_source_duration

template<typename Timer >

concept tsm::io::tick_source_duration

Initial value:

= requires(Timer timer) {
    { timer.ticks() } -> std::convertible_to<tsm::tick_duration>;
}

tick_source_rep

template<typename Timer >

concept tsm::io::tick_source_rep

Initial value:

= requires(Timer timer) {
    { timer.ticks() } -> std::convertible_to<tsm::tick_rep>;
}

uart

template<typename Bus >

concept tsm::io::uart

Initial value:

= 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>;
}