prinThor 0.0.3

The highly reliable but not necessarily functional 3D Printer firmware
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
120
121
122
123
124
125
126
127

#[allow(unused)]
use crate::hwa;
use crate::hwi;
pub use printhor_hwa_common::ControllerRef;
pub use crate::control::processor::GCodeProcessor;

#[cfg(feature = "with-defmt")]
pub use defmt;

#[cfg(feature = "with-defmt")]
#[allow(unused)]
pub use defmt::{trace, debug, info, warn, error};

pub mod devices;
pub mod controllers;
pub mod drivers;

//#region Main exports

pub use hwi::*;

//#endregion

pub mod mem {
    use crate::hwi;
    #[allow(unused)]
    #[inline]
    pub fn heap_current_size() -> u32 {
        hwi::heap_current_size()
    }
    #[allow(unused)]
    #[inline]
    pub fn heap_max_size() -> usize {
        hwi::HEAP_SIZE_BYTES
    }

    #[allow(unused)]
    #[inline]
    pub fn heap_current_usage_percentage() -> f32 {
        hwi::heap_current_usage_percentage()
    }

    #[allow(unused)]
    #[inline]
    pub fn stack_reservation_max_size() -> u32 {
        hwi::MAX_STATIC_MEMORY as u32

    }

    #[allow(unused)]
    #[inline]
    pub fn stack_reservation_current_size() -> u32 {
        hwi::stack_reservation_current_size()
    }

    #[allow(unused)]
    #[inline]
    pub fn stack_reservation_usage_percentage() -> f32 {
        let alloc = stack_reservation_current_size() as f32;
        let max = stack_reservation_max_size() as f32;
        (100.0f32 * alloc) / max
    }
}

#[cfg(feature = "with-display")]
pub mod display {
    pub use crate::hwi::device::DisplayDevice;
    #[allow(unused)]
    pub use crate::hwi::device::DisplayScreen;
}

/// Simple module to manage and measure static controller allocations in async tasks
pub mod task_allocations {
    use printhor_hwa_common::{EventBusRef, EventBusSubscriber, TrackedStaticCell};

    pub async fn init_control_subscriber(event_bus: EventBusRef) -> EventBusSubscriber<'static>  {
        static SUBS: TrackedStaticCell<EventBusRef> = TrackedStaticCell::new();
        let bi: &mut EventBusRef = SUBS.init("control_task::EventBusSubscriber", event_bus);
        bi.subscriber().await
    }

    #[cfg(feature = "with-printjob")]
    pub async fn init_printer_subscriber(event_bus: EventBusRef) -> EventBusSubscriber<'static>  {
        static SUBS: TrackedStaticCell<EventBusRef> = TrackedStaticCell::new();
        let bi: &mut EventBusRef = SUBS.init("printer_task::EventBusSubscriber", event_bus);
        bi.subscriber().await
    }

    #[cfg(all(feature = "integration-test"))]
    pub async fn init_integration_subscriber(event_bus: EventBusRef) -> EventBusSubscriber<'static>  {
        static SUBS: TrackedStaticCell<EventBusRef> = TrackedStaticCell::new();
        let bi: &mut EventBusRef = SUBS.init("integration_task::EventBusSubscriber", event_bus);
        bi.subscriber().await
    }

    /*
    #[cfg(feature = "with-sdcard")]
    pub async fn init_defer_subscriber(event_bus: hwa::EventBusRef) -> EventBusSubscriber<'static>  {
        static SUBS: TrackedStaticCell<hwa::EventBusRef> = TrackedStaticCell::new();
        let bi: &mut hwa::EventBusRef = SUBS.init("deferred_task::EventBusSubscriber", event_bus);
        bi.subscriber().await
    }
     */
}

#[cfg(feature = "with-sdcard")]
pub struct DummyTimeSource {
    
}

#[cfg(feature = "with-sdcard")]
impl embedded_sdmmc::TimeSource for DummyTimeSource {
    fn get_timestamp(&self) -> embedded_sdmmc::Timestamp {
        embedded_sdmmc::Timestamp {
            year_since_1970: 0,
            zero_indexed_month: 0,
            zero_indexed_day: 0,
            hours: 0,
            minutes: 0,
            seconds: 0,
        }
    }
}

pub type WatchdogRef = ControllerRef<hwi::device::Watchdog>;