flipperzero 0.16.0

Rust for Flipper Zero
Documentation 
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

//! Furi Kernel primitives.

use flipperzero_sys as sys;
use ufmt::derive::uDebug;

use crate::furi;

/// Check if CPU is in IRQ; or kernel running and IRQ is masked.
pub fn is_irq_or_masked() -> bool {
    unsafe { sys::furi_kernel_is_irq_or_masked() }
}

/// Check if kernel is running.
pub fn is_running() -> bool {
    unsafe { sys::furi_kernel_is_running() }
}

/// Kernel lock state.
#[derive(Clone, Copy, Debug, PartialEq, Eq, uDebug)]
pub enum LockState {
    /// normal scheduling
    Unlocked = 0,
    /// scheduling paused
    Locked = 1,
}

impl From<i32> for LockState {
    fn from(value: i32) -> Self {
        match value {
            0 => LockState::Unlocked,
            // Assume any non-zero value is `Locked``.
            // This can be modified if new lock states are added in the future.
            _ => LockState::Locked,
        }
    }
}

impl From<LockState> for i32 {
    fn from(value: LockState) -> Self {
        value as i32
    }
}

/// Lock kernel, pause process scheduling.
///
/// <div class="warning">This should never be called in an interrupt request context.</div>
///
/// Returns previous lock state.
pub fn lock() -> furi::Result<LockState> {
    let status = sys::furi::Status::from(unsafe { sys::furi_kernel_lock() });

    status.into_result().map(LockState::from)
}

/// Unlock kernel, resume process scheduling.
///
/// <div class="warning">This should never be called in an interrupt request context.</div>
///
/// Returns previous lock state.
pub fn unlock() -> furi::Result<LockState> {
    let status = sys::furi::Status::from(unsafe { sys::furi_kernel_unlock() });

    Ok(status.into_result()?.into())
}

/// Restore kernel lock state.
///
/// <div class="warning">This should never be called in an interrupt request context.</div>
///
/// Returns previous lock state.
pub fn restore_lock(state: LockState) -> furi::Result<LockState> {
    let status = sys::furi::Status::from(unsafe { sys::furi_kernel_restore_lock(state.into()) });

    Ok(status.into_result()?.into())
}

/// Return kernel tick frequency in hertz.
#[inline]
pub fn get_tick_frequency() -> u32 {
    unsafe { sys::furi_kernel_get_tick_frequency() }
}

/// Return current kernel tick value.
///
/// The duration of a tick depends on kernel configuration.
/// The value can be discovered with [`get_tick_frequency`].
#[inline]
pub fn get_tick() -> u32 {
    unsafe { sys::furi_get_tick() }
}