Struct esp_idf_hal::rmt::TxRmtDriver

pub struct TxRmtDriver<'d> { /* private fields */ }

The RMT transmitter driver.

Use TxRmtDriver::start() or TxRmtDriver::start_blocking() to transmit pulses.

See the rmt module for more information.

Implementations

impl<'d> TxRmtDriver<'d>

pub fn new<C: RmtChannel>( _channel: impl Peripheral<P = C> + 'd, pin: impl Peripheral<P = impl OutputPin> + 'd, config: &TransmitConfig ) -> Result<Self, EspError>

Initialise the rmt module with the specified pin, channel and configuration.

To uninstall the driver just drop it.

Internally this calls rmt_config() and rmt_driver_install().

pub fn counter_clock(&self) -> Result<Hertz, EspError>

Get speed of the channel’s internal counter clock.

This calls rmt_get_counter_clock() internally. It is used for calculating the number of ticks per second for pulses.

See Pulse::new_with_duration().

pub fn start<S>(&mut self, signal: S) -> Result<(), EspError>

where S: Signal,

Start sending the given signal without blocking.

signal is captured for safety so that the user can’t change the data while transmitting.

pub fn start_blocking<S>(&mut self, signal: &S) -> Result<(), EspError>

where S: Signal + ?Sized,

Start sending the given signal while blocking.

pub fn start_iter<T>(&mut self, iter: T) -> Result<(), EspError>

where T: Iterator<Item = Symbol> + Send + 'static,

Transmit all items in iter without blocking.

Note that this requires iter to be [Box]ed for an allocation free version see Self::start_iter_blocking.

Warning

Iteration of iter happens inside an interrupt handler so beware of side-effects that don’t work in interrupt handlers. Iteration must also be fast so that there are no time-gaps between successive transmissions where the perhipheral has to wait for items. This can cause weird behavior and can be counteracted with increasing [Config::mem_block_num] or making iteration more efficient.

pub fn start_iter_blocking<T>(&mut self, iter: T) -> Result<(), EspError>

where T: Iterator<Item = Symbol> + Send,

Transmit all items in iter, blocking until all items are transmitted.

This method does not require any allocations since the thread is paused until all items are transmitted. The iterator lives on the stack and will be dropped after all items are written and before this method returns.

Warning

Iteration of iter happens inside an interrupt handler so beware of side-effects that don’t work in interrupt handlers. Iteration must also be fast so that there are no time-gaps between successive transmissions where the perhipheral has to wait for items. This can cause weird behavior and can be counteracted with increasing [Config::mem_block_num] or making iteration more efficient.

pub fn stop(&mut self) -> Result<(), EspError>

Stop transmitting.

pub fn set_looping(&mut self, looping: Loop) -> Result<(), EspError>

pub fn channel(&self) -> rmt_channel_t

Trait Implementations

impl<'d> Drop for TxRmtDriver<'d>

fn drop(&mut self)

Stop transmitting and release the driver.

impl<'d> Send for TxRmtDriver<'d>