Skip to content
Snippets Groups Projects
Select Git revision
  • 2d80f3631bc3bf382ae24c25dbf8ff33af2ad430
  • master default
  • claim_mut_new
  • nested_resources
  • test_roread
  • noread
  • v0.2.0
  • v0.1.1
  • v0.1.0
9 results

two-tasks.rs

Blame
  • nested.rs 2.93 KiB
    //! Nesting claims and how the preemption threshold works
    //!
    //! If you run this program you'll hit the breakpoints as indicated by the
    //! letters in the comments: A, then B, then C, etc.
    
    #![deny(unsafe_code)]
    #![feature(const_fn)]
    #![feature(proc_macro)]
    #![no_std]
    
    extern crate cortex_m_rtfm as rtfm;
    extern crate stm32f103xx;
    
    use stm32f103xx::Interrupt;
    use rtfm::{app, Resource, Threshold};
    
    app! {
        device: stm32f103xx,
    
        resources: {
            static LOW: u64 = 0;
            static HIGH: u64 = 0;
        },
    
        tasks: {
            EXTI0: {
                enabled: true,
                path: exti0,
                priority: 1,
                resources: [LOW, HIGH],
            },
    
            EXTI1: {
                enabled: true,
                path: exti1,
                priority: 2,
                resources: [LOW],
            },
    
            EXTI2: {
                enabled: true,
                path: exti2,
                priority: 3,
                resources: [HIGH],
            },
        },
    }
    
    fn init(_p: init::Peripherals, _r: init::Resources) {}
    
    fn idle() -> ! {
        // sets task `exti0` as pending
        //
        // because `exti0` has higher priority than `idle` it will be executed
        // immediately
        rtfm::set_pending(Interrupt::EXTI0); // ~> exti0
    
        loop {
            rtfm::wfi();
        }
    }
    
    fn exti0(t: &mut Threshold, r: EXTI0::Resources) {
        // because this task has a priority of 1 the preemption threshold is also 1
    
        let mut low = r.LOW;
        let mut high = r.HIGH;
    
        // A
        rtfm::bkpt();
    
        // because `exti1` has higher priority than `exti0` it can preempt it
        rtfm::set_pending(Interrupt::EXTI1); // ~> exti1
    
        // a claim creates a critical section
        low.claim_mut(t, |_low, t| {
            // this claim increases the preemption threshold to 2
            // just high enough to not race with task `exti1` for access to the
            // `LOW` resource
    
            // C
            rtfm::bkpt();
    
            // now `exti1` can't preempt this task because its priority is equal to
            // the current preemption threshold
            rtfm::set_pending(Interrupt::EXTI1);
    
            // but `exti2` can, because its priority is higher than the current
            // preemption threshold
            rtfm::set_pending(Interrupt::EXTI2); // ~> exti2
    
            // E
            rtfm::bkpt();
    
            // claims can be nested
            high.claim_mut(t, |_high, _| {
                // This claim increases the preemption threshold to 3
    
                // now `exti2` can't preempt this task
                rtfm::set_pending(Interrupt::EXTI2);
    
                // F
                rtfm::bkpt();
            });
    
            // upon leaving the critical section the preemption threshold drops to 2
            // and `exti2` immediately preempts this task
            // ~> exti2
        });
    
        // once again the preemption threshold drops to 1
        // now the pending `exti1` can preempt this task
        // ~> exti1
    }
    
    fn exti1(_t: &mut Threshold, _r: EXTI1::Resources) {
        // B, H
        rtfm::bkpt();
    }
    
    fn exti2(_t: &mut Threshold, _r: EXTI2::Resources) {
        // D, G
        rtfm::bkpt();
    }