Trait microbit::hal::prelude::_embedded_hal_Pwm

pub trait _embedded_hal_Pwm {
    type Channel;
    type Time;
    type Duty;
    fn disable(&mut self, channel: Self::Channel);
    fn enable(&mut self, channel: Self::Channel);
    fn get_period(&self) -> Self::Time;
    fn get_duty(&self, channel: Self::Channel) -> Self::Duty;
    fn get_max_duty(&self) -> Self::Duty;
    fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty);
    fn set_period<P>(&mut self, period: P)
    where
        P: Into<Self::Time>;
}

Pulse Width Modulation

This trait is available if embedded-hal is built with the "unproven" feature.

Examples

Use this interface to control the power output of some actuator

extern crate embedded_hal as hal;

use hal::prelude::*;

fn main() {
    let mut pwm: Pwm1 = {
        // ..
    };

    pwm.set_period(1.khz());

    let max_duty = pwm.get_max_duty();

    // brightest LED
    pwm.set_duty(Channel::_1, max_duty);

    // dimmer LED
    pwm.set_duty(Channel::_2, max_duty / 4);
}

Associated Types

type Channel

Enumeration of channels that can be used with this Pwm interface

If your Pwm interface has no channels you can use the type () here

type Time

A time unit that can be converted into a human time unit (e.g. seconds)

type Duty

Type for the duty methods

The implementer is free to choose a float / percentage representation (e.g. 0.0 .. 1.0) or an integer representation (e.g. 0 .. 65535)

Required methods

fn disable(&mut self, channel: Self::Channel)

Disables a PWM channel

fn enable(&mut self, channel: Self::Channel)

Enables a PWM channel

fn get_period(&self) -> Self::Time

Returns the current PWM period

fn get_duty(&self, channel: Self::Channel) -> Self::Duty

Returns the current duty cycle

fn get_max_duty(&self) -> Self::Duty

Returns the maximum duty cycle value

fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty)

Sets a new duty cycle

fn set_period<P>(&mut self, period: P) where
    P: Into<Self::Time>, 

Sets a new PWM period

Implementors

impl<T> Pwm for Pwm<T> where
    T: Instance, 

type Channel = Channel

type Duty = u16

type Time = Hertz

pub fn enable(&mut self, channel: <Pwm<T> as Pwm>::Channel)

pub fn disable(&mut self, channel: <Pwm<T> as Pwm>::Channel)

pub fn get_duty(
    &self,
    channel: <Pwm<T> as Pwm>::Channel
) -> <Pwm<T> as Pwm>::Duty

pub fn set_duty(
    &mut self,
    channel: <Pwm<T> as Pwm>::Channel,
    duty: <Pwm<T> as Pwm>::Duty
)

pub fn get_max_duty(&self) -> <Pwm<T> as Pwm>::Duty

pub fn get_period(&self) -> <Pwm<T> as Pwm>::Time

pub fn set_period<P>(&mut self, period: P) where
    P: Into<<Pwm<T> as Pwm>::Time>,