avr-oxide 0.0.2

An extremely simply Rusty operating system for AVR microcontrollers
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

/* concurrency.rs
 *
 * Developed by Tim Walls <tim.walls@snowgoons.com>
 * Copyright (c) All Rights Reserved, Tim Walls
 */
//! @todo documentation for this module
//!
//!

// Imports ===================================================================
#[cfg(not(target_arch="avr"))]
pub mod imp {
  pub struct MutexRc<A> {
    inner: core::cell::RefCell<A>
  }

  pub struct CriticalSection {
  }

  pub fn atomic<F,R>(f: F) -> R
  where
    F: FnOnce(&CriticalSection) -> R
  {
    println!("ATOMIC SECTION");
    let res = f(&CriticalSection {});
    println!("END OF ATOMIC SECTION");
    res
  }

  pub unsafe fn enable_interrupts() {
    println!("ENABLED INTERRUPTS");
  }
  pub unsafe fn disable_interrupts() {
    println!("DISABLED INTERRUPTS");
  }

  pub fn wait_for_interrupt() {
    std::thread::sleep(std::time::Duration::from_millis(100));
  }

  impl<A> MutexRc<A> {
    pub const fn new(contains: A) -> Self {
      MutexRc {
        inner: core::cell::RefCell::new(contains)
      }
    }

    pub fn borrow<'cs>(&'cs self, cs: &'cs CriticalSection) -> core::cell::Ref<'cs,A> {
      self.inner.borrow()
    }

    pub fn borrow_mut<'cs>(&'cs self, cs: &'cs CriticalSection) -> core::cell::RefMut<'cs,A> {
      self.inner.borrow_mut()
    }
  }
}

#[cfg(target_arch="avr")]
pub mod imp {
  #[cfg(feature="atmega4809")]
  extern crate avr_device_snowgoons as avr_device;
  #[cfg(not(feature="atmega4809"))]
  extern crate avr_device_mainline as avr_device;

  pub struct MutexRc<A> {
    inner: avr_device::interrupt::Mutex<core::cell::RefCell<A>>
  }

  impl<A> MutexRc<A> {
    pub const fn new(contains: A) -> Self {
      MutexRc {
        inner: avr_device::interrupt::Mutex::new(core::cell::RefCell::new(contains))
      }
    }

    pub fn borrow<'cs>(&'cs self, cs: &'cs avr_device::interrupt::CriticalSection) -> core::cell::Ref<'cs,A> {
      self.inner.borrow(cs).borrow()
    }

    pub fn borrow_mut<'cs>(&'cs self, cs: &'cs avr_device::interrupt::CriticalSection) -> core::cell::RefMut<'cs,A> {
      self.inner.borrow(cs).borrow_mut()
    }
  }

  #[inline(always)]
  pub fn atomic<F,R>(f: F) -> R
  where
    F: FnOnce(&avr_device::interrupt::CriticalSection) -> R
  {
    avr_device::interrupt::free(f)
  }

  #[inline(always)]
  pub unsafe fn enable_interrupts(){
    llvm_asm!("sei" :::: "volatile")
  }

  #[inline(always)]
  pub unsafe fn disable_interrupts() {
    llvm_asm!("cli" :::: "volatile")
  }

  #[inline(always)]
  pub fn wait_for_interrupt() {
    unsafe {
      llvm_asm!("sleep");
    }
  }

}


// Declarations ==============================================================


// Code ======================================================================


// Tests =====================================================================